diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 1e5c47c2be25..e00ae047ae8d 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,9 +51,6 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-basic.test",
-    "check-bound.test",
-    "check-dynamic-typing.test",
     "check-expressions.test",
     "check-functions.test",
     "check-generic-subtyping.test",
diff --git a/test-data/unit/check-basic.test b/test-data/unit/check-basic.test
index e10e69267c5a..408c3599672b 100644
--- a/test-data/unit/check-basic.test
+++ b/test-data/unit/check-basic.test
@@ -2,8 +2,8 @@
 [out]
 
 [case testAssignmentAndVarDef]
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 if int():
     a = a
 if int():
@@ -17,14 +17,14 @@ class A:
 class B:
     def __init__(self): pass
 
-x = None # type: A
+x: A
 x = A()
 if int():
     x = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 [case testInheritInitFromObject]
 class A(object): pass
 class B(object): pass
-x = None # type: A
+x: A
 if int():
     x = A()
 if int():
@@ -32,8 +32,8 @@ if int():
 [case testImplicitInheritInitFromObject]
 class A: pass
 class B: pass
-x = None # type: A
-o = None # type: object
+x: A
+o: object
 if int():
     x = o # E: Incompatible types in assignment (expression has type "object", variable has type "A")
 if int():
@@ -59,7 +59,7 @@ x = B() # type: A
 y = A() # type: B  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 [case testDeclaredVariableInParentheses]
 
-(x) = None # type: int
+(x) = 2 # type: int
 if int():
     x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 if int():
@@ -135,8 +135,8 @@ main:6: error: Missing positional arguments "baz", "bas" in call to "foo"
 
 [case testLocalVariables]
 def f() -> None:
-  x = None # type: A
-  y = None # type: B
+  x: A
+  y: B
   if int():
       x = x
       x = y # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -229,12 +229,12 @@ reveal_type(__annotations__)  # N: Revealed type is "builtins.dict[builtins.str,
 [case testLocalVariableShadowing]
 class A: pass
 class B: pass
-a = None # type: A
+a: A
 if int():
     a = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
     a = A()
 def f() -> None:
-  a = None # type: B
+  a: B
   if int():
       a = A()     # E: Incompatible types in assignment (expression has type "A", variable has type "B")
       a = B()
@@ -242,8 +242,8 @@ a = B()       # E: Incompatible types in assignment (expression has type "B", va
 a = A()
 [case testGlobalDefinedInBlockWithType]
 class A: pass
-while A:
-    a = None # type: A
+while 1:
+    a: A
     if int():
         a = A()
         a = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")
diff --git a/test-data/unit/check-bound.test b/test-data/unit/check-bound.test
index eb97bde32e1f..1c713fd77c38 100644
--- a/test-data/unit/check-bound.test
+++ b/test-data/unit/check-bound.test
@@ -37,15 +37,16 @@ T = TypeVar('T', bound=A)
 class G(Generic[T]):
     def __init__(self, x: T) -> None: pass
 
-v = None # type: G[A]
-w = None # type: G[B]
-x = None # type: G[str] # E: Type argument "str" of "G" must be a subtype of "A"
+v: G[A]
+w: G[B]
+x: G[str]  # E: Type argument "str" of "G" must be a subtype of "A"
 y = G('a') # E: Value of type variable "T" of "G" cannot be "str"
 z = G(A())
 z = G(B())
 
 
 [case testBoundVoid]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 T = TypeVar('T', bound=int)
 class C(Generic[T]):
@@ -70,10 +71,11 @@ def g(): pass
 
 f(g())
 C(g())
-z = None # type: C
+z: C
 
 
 [case testBoundHigherOrderWithVoid]
+# flags: --no-strict-optional
 from typing import TypeVar, Callable
 class A: pass
 T = TypeVar('T', bound=A)
diff --git a/test-data/unit/check-dynamic-typing.test b/test-data/unit/check-dynamic-typing.test
index dd4cc1579639..0dc05a7a0ea1 100644
--- a/test-data/unit/check-dynamic-typing.test
+++ b/test-data/unit/check-dynamic-typing.test
@@ -4,8 +4,8 @@
 
 [case testAssignmentWithDynamic]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d # Everything ok
@@ -20,8 +20,9 @@ class A: pass
 
 [case testMultipleAssignmentWithDynamic]
 from typing import Any
-d = None # type: Any
-a, b = None, None # type: (A, B)
+d: Any
+a: A
+b: B
 
 if int():
     d, a = b, b    # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -51,7 +52,8 @@ from typing import Any
 def f(x: Any) -> 'A':
     pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -75,7 +77,8 @@ from typing import Any
 def f(x: 'A') -> Any:
     pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 a = f(b) # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 
@@ -88,10 +91,10 @@ class B: pass
 
 [case testBinaryOperationsWithDynamicLeftOperand]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-c = None # type: C
-b = None # type: bool
+d: Any
+a: A
+c: C
+b: bool
 n = 0
 
 d in a  # E: Unsupported right operand type for in ("A")
@@ -151,10 +154,10 @@ class dict: pass
 
 [case testBinaryOperationsWithDynamicAsRightOperand]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-c = None # type: C
-b = None # type: bool
+d: Any
+a: A
+c: C
+b: bool
 n = 0
 
 a and d
@@ -224,9 +227,9 @@ class dict: pass
 
 [case testDynamicWithUnaryExpressions]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-b = None # type: bool
+d: Any
+a: A
+b: bool
 if int():
     a = not d # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -238,8 +241,8 @@ class A: pass
 
 [case testDynamicWithMemberAccess]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d.foo(a()) # E: "A" not callable
@@ -256,8 +259,8 @@ class A: pass
 
 [case testIndexingWithDynamic]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d[a()] # E: "A" not callable
@@ -270,10 +273,10 @@ d[a], d[a] = a, a
 
 class A: pass
 
-[case testTupleExpressionsWithDynamci]
+[case testTupleExpressionsWithDynamic]
 from typing import Tuple, Any
-t2 = None # type: Tuple[A, A]
-d = None # type: Any
+t2: Tuple[A, A]
+d: Any
 
 if int():
     t2 = (d, d, d)  # E: Incompatible types in assignment (expression has type "Tuple[Any, Any, Any]", variable has type "Tuple[A, A]")
@@ -289,9 +292,9 @@ class A: pass
 class B: pass
 def f() -> None: pass
 
-d = None # type: Any
-a = None # type: A
-b = None # type: B
+d: Any
+a: A
+b: B
 if int():
     b = cast(A, d) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 if int():
@@ -309,8 +312,8 @@ def g(a: 'A') -> None:
 class A: pass
 class B: pass
 
-d = None # type: Any
-t = None # type: Tuple[A, A]
+d: Any
+t: Tuple[A, A]
 # TODO: callable types, overloaded functions
 
 d = None # All ok
@@ -362,10 +365,10 @@ class A: pass
 
 [case testImplicitGlobalFunctionSignature]
 from typing import Any, Callable
-x = None # type: Any
-a = None # type: A
-g = None # type: Callable[[], None]
-h = None # type: Callable[[A], None]
+x: Any
+a: A
+g: Callable[[], None]
+h: Callable[[A], None]
 
 def f(x): pass
 
@@ -384,10 +387,10 @@ class A: pass
 
 [case testImplicitGlobalFunctionSignatureWithDifferentArgCounts]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+a: A
 
 def f0(): pass
 def f2(x, y): pass
@@ -415,16 +418,17 @@ from typing import Callable
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 def f01(x = b): pass
 def f13(x, y = b, z = b): pass
 
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-g3 = None # type: Callable[[A, A, A], None]
-g4 = None # type: Callable[[A, A, A, A], None]
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+g3: Callable[[A, A, A], None]
+g4: Callable[[A, A, A, A], None]
 
 f01(a, a)       # E: Too many arguments for "f01"
 f13()           # E: Missing positional argument "x" in call to "f13"
@@ -456,7 +460,7 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testSkipTypeCheckingWithImplicitSignature]
-a = None # type: A
+a: A
 def f():
     a()
 def g(x):
@@ -469,7 +473,7 @@ class A: pass
 [builtins fixtures/bool.pyi]
 
 [case testSkipTypeCheckingWithImplicitSignatureAndDefaultArgs]
-a = None # type: A
+a: A
 def f(x=a()):
     a()
 def g(x, y=a, z=a()):
@@ -478,10 +482,10 @@ class A: pass
 
 [case testImplicitMethodSignature]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+a: A
 
 if int():
     g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
@@ -502,7 +506,7 @@ if int():
 
 [case testSkipTypeCheckingImplicitMethod]
 
-a = None # type: A
+a: A
 class A:
     def f(self):
         a()
@@ -511,9 +515,9 @@ class A:
 
 [case testImplicitInheritedMethod]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+a: A
 
 if int():
     g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
@@ -559,9 +563,9 @@ from typing import Callable
 class A:
   def __init__(self, a, b): pass
 
-f1 = None # type: Callable[[A], A]
-f2 = None # type: Callable[[A, A], A]
-a = None # type: A
+f1: Callable[[A], A]
+f2: Callable[[A, A], A]
+a: A
 
 A(a)   # E: Missing positional argument "b" in call to "A"
 if int():
@@ -576,7 +580,7 @@ class A: pass
 class B:
     def __init__(self): pass
 
-t = None # type: type
+t: type
 t = A
 t = B
 -- Type compatibility
@@ -585,11 +589,11 @@ t = B
 
 [case testTupleTypeCompatibility]
 from typing import Any, Tuple
-t1 = None # type: Tuple[Any, A]
-t2 = None # type: Tuple[A, Any]
-t3 = None # type: Tuple[Any, Any]
-t4 = None # type: Tuple[A, A]
-t5 = None # type: Tuple[Any, Any, Any]
+t1: Tuple[Any, A]
+t2: Tuple[A, Any]
+t3: Tuple[Any, Any]
+t4: Tuple[A, A]
+t5: Tuple[Any, Any, Any]
 
 def f(): t1, t2, t3, t4, t5 # Prevent redefinition
 
@@ -614,11 +618,11 @@ class A: pass
 [builtins fixtures/tuple.pyi]
 
 [case testFunctionTypeCompatibilityAndReturnTypes]
-from typing import Any, Callable
-f1 = None # type: Callable[[], Any]
-f11 = None # type: Callable[[], Any]
-f2 = None # type: Callable[[], A]
-f3 = None # type: Callable[[], None]
+from typing import Any, Callable, Optional
+f1: Callable[[], Any]
+f11: Callable[[], Any]
+f2: Callable[[], Optional[A]]
+f3: Callable[[], None]
 
 f2 = f3
 
@@ -631,9 +635,9 @@ class A: pass
 
 [case testFunctionTypeCompatibilityAndArgumentTypes]
 from typing import Any, Callable
-f1 = None # type: Callable[[A, Any], None]
-f2 = None # type: Callable[[Any, A], None]
-f3 = None # type: Callable[[A, A], None]
+f1: Callable[[A, Any], None]
+f2: Callable[[Any, A], None]
+f3: Callable[[A, A], None]
 
 f1 = f1
 f1 = f2
@@ -651,8 +655,8 @@ class A: pass
 
 [case testFunctionTypeCompatibilityAndArgumentCounts]
 from typing import Any, Callable
-f1 = None # type: Callable[[Any], None]
-f2 = None # type: Callable[[Any, Any], None]
+f1: Callable[[Any], None]
+f2: Callable[[Any, Any], None]
 
 if int():
     f1 = f2 # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
@@ -664,7 +668,8 @@ if int():
 
 [case testOverridingMethodWithDynamicTypes]
 from typing import Any
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 b.f(b) # E: Argument 1 to "f" of "B" has incompatible type "B"; expected "A"
 a = a.f(b)
@@ -682,8 +687,8 @@ class A(B):
 [builtins fixtures/tuple.pyi]
 
 [case testOverridingMethodWithImplicitDynamicTypes]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 b.f(b) # E: Argument 1 to "f" of "B" has incompatible type "B"; expected "A"
 a = a.f(b)