diff --git a/.coveragerc b/.coveragerc
index 4386da5..4c9bab1 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -12,7 +12,6 @@ exclude_lines =
     raise AssertionError
     raise NotImplementedError
     raise TypeError
-    return NotImplemented
     assert False
     @abstractmethod
     \.\.\.
diff --git a/omegaconf/_utils.py b/omegaconf/_utils.py
index 126fca1..e3c0683 100644
--- a/omegaconf/_utils.py
+++ b/omegaconf/_utils.py
@@ -336,7 +336,18 @@ def is_primitive_dict(obj: Any) -> bool:
 
 def is_dict_annotation(type_: Any) -> bool:
     origin = getattr(type_, "__origin__", None)
-    return origin is Dict or origin is dict
+    if sys.version_info < (3, 7, 0):
+        return origin is Dict or type_ is Dict  # pragma: no cover
+    else:
+        return origin is dict  # pragma: no cover
+
+
+def is_list_annotation(type_: Any) -> bool:
+    origin = getattr(type_, "__origin__", None)
+    if sys.version_info < (3, 7, 0):
+        return origin is List or type_ is List  # pragma: no cover
+    else:
+        return origin is list  # pragma: no cover
 
 
 def is_dict_subclass(type_: Any) -> bool:
@@ -435,6 +446,53 @@ def _get_value(value: Any) -> Any:
     return value
 
 
+def get_ref_type(obj: Any, key: Any = None) -> Optional[Type[Any]]:
+    from omegaconf import DictConfig, ListConfig
+    from omegaconf.base import Container, Node
+    from omegaconf.nodes import ValueNode
+
+    def none_as_any(t: Optional[Type[Any]]) -> Union[Type[Any], Any]:
+        if t is None:
+            return Any
+        else:
+            return t
+
+    if isinstance(obj, Container) and key is not None:
+        obj = obj._get_node(key)
+
+    is_optional = True
+    ref_type = None
+    if isinstance(obj, ValueNode):
+        is_optional = obj._is_optional()
+        ref_type = obj._metadata.ref_type
+    elif isinstance(obj, Container):
+        if isinstance(obj, Node):
+            ref_type = obj._metadata.ref_type
+        if ref_type is Any:
+            pass
+        elif not is_structured_config(ref_type):
+            kt = none_as_any(obj._metadata.key_type)
+            vt = none_as_any(obj._metadata.element_type)
+            if isinstance(obj, DictConfig):
+                ref_type = Dict[kt, vt]  # type: ignore
+            elif isinstance(obj, ListConfig):
+                ref_type = List[vt]  # type: ignore
+        is_optional = obj._is_optional()
+    else:
+        if isinstance(obj, dict):
+            ref_type = Dict[Any, Any]
+        elif isinstance(obj, (list, tuple)):
+            ref_type = List[Any]
+        else:
+            ref_type = get_type_of(obj)
+
+    ref_type = none_as_any(ref_type)
+    if is_optional and ref_type is not Any:
+        ref_type = Optional[ref_type]
+
+    return ref_type
+
+
 def format_and_raise(
     node: Any,
     key: Any,
@@ -480,17 +538,11 @@ def format_and_raise(
 
         full_key = node._get_full_key(key=key)
 
-        ref_type = OmegaConf.get_ref_type(node)
         object_type = OmegaConf.get_type(node)
-
         object_type_str = type_str(object_type)
-        if ref_type is None:
-            ref_type_str = "Any"
-        else:
-            ref_type_str = type_str(ref_type)
 
-        if node._metadata.optional and ref_type_str != "Any":
-            ref_type_str = f"Optional[{ref_type_str}]"
+        ref_type = get_ref_type(node)
+        ref_type_str = type_str(ref_type)
 
     msg = string.Template(msg).substitute(
         REF_TYPE=ref_type_str,
@@ -537,6 +589,9 @@ def format_and_raise(
 
 
 def type_str(t: Any) -> str:
+    is_optional, t = _resolve_optional(t)
+    if t is Any:
+        return "Any"
     if sys.version_info < (3, 7, 0):  # pragma: no cover
         # Python 3.6
         if hasattr(t, "__name__"):
@@ -562,6 +617,10 @@ def type_str(t: Any) -> str:
     args = getattr(t, "__args__", None)
     if args is not None:
         args = ", ".join([type_str(t) for t in (list(t.__args__))])
-        return f"{name}[{args}]"
+        ret = f"{name}[{args}]"
     else:
-        return name
+        ret = name
+    if is_optional:
+        return f"Optional[{ret}]"
+    else:
+        return ret
diff --git a/omegaconf/base.py b/omegaconf/base.py
index 2c25eca..e18302c 100644
--- a/omegaconf/base.py
+++ b/omegaconf/base.py
@@ -32,6 +32,10 @@ class ContainerMetadata(Metadata):
     key_type: Any = None
     element_type: Any = None
 
+    def __post_init__(self) -> None:
+        assert self.key_type is None or isinstance(self.key_type, type)
+        assert self.element_type is None or isinstance(self.element_type, type)
+
 
 class Node(ABC):
     _metadata: Metadata
diff --git a/omegaconf/basecontainer.py b/omegaconf/basecontainer.py
index 96e7dbb..6c5b826 100644
--- a/omegaconf/basecontainer.py
+++ b/omegaconf/basecontainer.py
@@ -13,8 +13,6 @@ from ._utils import (
     _is_interpolation,
     get_value_kind,
     get_yaml_loader,
-    is_dict_annotation,
-    is_dict_subclass,
     is_primitive_container,
     is_primitive_dict,
     is_structured_config,
@@ -325,23 +323,23 @@ class BaseContainer(Container, ABC):
             target_node = isinstance(target_node_ref, ValueNode)
 
         def wrap(key: Any, val: Any) -> Node:
-            if is_dict_annotation(self._metadata.ref_type) or (
-                not is_primitive_dict(self._metadata.ref_type)
-                and is_dict_subclass(self._metadata.ref_type)
-            ):
+            is_optional = True
+            if not is_structured_config(val):
                 ref_type = self._metadata.element_type
             else:
                 target = self._get_node(key)
                 if target is None:
                     if is_structured_config(val):
                         ref_type = OmegaConf.get_type(val)
-                    else:
-                        # assignment
-                        ref_type = OmegaConf.get_ref_type(val)
                 else:
-                    ref_type = OmegaConf.get_ref_type(target)
+                    is_optional = target._is_optional()
+                    ref_type = target._metadata.ref_type
             return _maybe_wrap(
-                ref_type=ref_type, key=key, value=val, is_optional=True, parent=self
+                ref_type=ref_type,
+                key=key,
+                value=val,
+                is_optional=is_optional,
+                parent=self,
             )
 
         def assign(value_key: Any, value_to_assign: Any) -> None:
@@ -454,7 +452,7 @@ class BaseContainer(Container, ABC):
         from .listconfig import ListConfig
         from .omegaconf import _select_one
 
-        if not isinstance(key, (int, str, Enum, slice)):
+        if not isinstance(key, (int, str, Enum, slice, type(None))):
             return ""
 
         def _slice_to_str(x: slice) -> str:
diff --git a/omegaconf/dictconfig.py b/omegaconf/dictconfig.py
index fbac511..f90a894 100644
--- a/omegaconf/dictconfig.py
+++ b/omegaconf/dictconfig.py
@@ -17,7 +17,6 @@ from typing import (
 from ._utils import (
     ValueKind,
     _is_interpolation,
-    get_dict_key_value_types,
     get_structured_config_data,
     get_type_of,
     get_value_kind,
@@ -25,6 +24,7 @@ from ._utils import (
     is_primitive_dict,
     is_structured_config,
     is_structured_config_frozen,
+    type_str,
 )
 from .base import Container, ContainerMetadata, Node
 from .basecontainer import DEFAULT_VALUE_MARKER, BaseContainer
@@ -33,6 +33,7 @@ from .errors import (
     ConfigKeyError,
     KeyValidationError,
     MissingMandatoryValue,
+    OmegaConfBaseException,
     ReadonlyConfigError,
     UnsupportedInterpolationType,
     ValidationError,
@@ -49,10 +50,11 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
         content: Union[Dict[str, Any], Any],
         key: Any = None,
         parent: Optional[Container] = None,
-        ref_type: Optional[Type[Any]] = None,
+        ref_type: Union[Type[Any], Any] = None,
+        key_type: Optional[Type[Any]] = None,
+        element_type: Optional[Type[Any]] = None,
         is_optional: bool = True,
     ) -> None:
-        key_type, element_type = get_dict_key_value_types(ref_type)
         super().__init__(
             parent=parent,
             metadata=ContainerMetadata(
@@ -139,7 +141,11 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
             if key is not None:
                 node = self._get_node(key)
                 if node is not None and not node._is_optional():
-                    raise ValidationError("field '$FULL_KEY' is not Optional")
+                    self._format_and_raise(
+                        key=key,
+                        value=value,
+                        cause=ValidationError("field '$FULL_KEY' is not Optional"),
+                    )
             else:
                 if not self._is_optional():
                     raise ValidationError("field '$FULL_KEY' is not Optional")
@@ -179,33 +185,30 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
         if value is None:
             return
 
-        target_type = OmegaConf.get_ref_type(target)
+        target_type = target._metadata.ref_type
         value_type = OmegaConf.get_type(value)
 
         if is_dict(value_type) and is_dict(target_type):
             return
 
-        if is_assign:
-            # assign
-            validation_error = (
-                target_type is not None
-                and value_type is not None
-                and not issubclass(value_type, target_type)
-            )
-        else:
+        # is assignment illegal?
+        validation_error = (
+            target_type is not None
+            and value_type is not None
+            and not issubclass(value_type, target_type)
+        )
+
+        if not is_assign:
             # merge
-            validation_error = not is_dict(value_type) and (
-                target_type is not None
-                and value_type is not None
-                and not issubclass(value_type, target_type)
-            )
+            # Merging of a dictionary is allowed even if assignment is illegal (merge would do deeper checks)
+            validation_error = not is_dict(value_type) and validation_error
 
         if validation_error:
             assert value_type is not None
             assert target_type is not None
             msg = (
-                f"Invalid type assigned : {value_type.__name__} is not a "
-                f"subclass of {target_type.__name__}. value: {value}"
+                f"Invalid type assigned : {type_str(value_type)} is not a "
+                f"subclass of {type_str(target_type)}. value: {value}"
             )
             raise ValidationError(msg)
 
@@ -222,24 +225,23 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
                 except KeyValidationError:
                     pass
             raise KeyValidationError("Incompatible key type '$KEY_TYPE'")
+        elif key_type == str:
+            if not isinstance(key, str):
+                raise KeyValidationError(
+                    f"Key $KEY ($KEY_TYPE) is incompatible with ({key_type.__name__})"
+                )
+            return key
+        elif issubclass(key_type, Enum):
+            try:
+                ret = EnumNode.validate_and_convert_to_enum(key_type, key)
+                assert ret is not None
+                return ret
+            except ValidationError as e:
+                raise KeyValidationError(
+                    f"Key '$KEY' is incompatible with ({key_type.__name__}) : {e}"
+                )
         else:
-            if key_type == str:
-                if not isinstance(key, str):
-                    raise KeyValidationError(
-                        f"Key $KEY ($KEY_TYPE) is incompatible with ({key_type.__name__})"
-                    )
-                return key
-            elif issubclass(key_type, Enum):
-                try:
-                    ret = EnumNode.validate_and_convert_to_enum(key_type, key)
-                    assert ret is not None
-                    return ret
-                except ValidationError as e:
-                    raise KeyValidationError(
-                        f"Key '$KEY' is incompatible with ({key_type.__name__}) : {e}"
-                    )
-            else:
-                assert False
+            assert False
 
     def __setitem__(self, key: Union[str, Enum], value: Any) -> None:
 
@@ -272,6 +274,8 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
         try:
             self.__set_impl(key, value)
         except Exception as e:
+            if isinstance(e, OmegaConfBaseException) and e._initialized:
+                raise e
             self._format_and_raise(key=key, value=value, cause=e)
             assert False
 
@@ -506,7 +510,6 @@ class DictConfig(BaseContainer, MutableMapping[str, Any]):
                 self.__dict__["_metadata"] = copy.deepcopy(value._metadata)
 
             elif isinstance(value, dict):
-                self._metadata.object_type = self._metadata.ref_type
                 for k, v in value.items():
                     self.__setitem__(k, v)
             else:
diff --git a/omegaconf/listconfig.py b/omegaconf/listconfig.py
index b6794e6..10ad04f 100644
--- a/omegaconf/listconfig.py
+++ b/omegaconf/listconfig.py
@@ -18,7 +18,6 @@ from ._utils import (
     ValueKind,
     _get_value,
     format_and_raise,
-    get_list_element_type,
     get_value_kind,
     is_primitive_list,
     isint,
@@ -45,15 +44,14 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
         content: Union[List[Any], Tuple[Any, ...], str, None],
         key: Any = None,
         parent: Optional[Container] = None,
-        ref_type: Optional[Type[Any]] = None,
+        element_type: Optional[Type[Any]] = None,
         is_optional: bool = True,
     ) -> None:
         try:
-            element_type = get_list_element_type(ref_type)
             super().__init__(
                 parent=parent,
                 metadata=ContainerMetadata(
-                    ref_type=ref_type,
+                    ref_type=None,
                     object_type=list,
                     key=key,
                     optional=is_optional,
@@ -400,9 +398,9 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
     def _iter_ex(self, resolve: bool) -> Iterator[Any]:
         try:
             if self._is_none():
-                raise TypeError("Cannot iterate on ListConfig object representing None")
+                raise TypeError("Cannot iterate a ListConfig object representing None")
             if self._is_missing():
-                raise MissingMandatoryValue("Cannot iterate on a missing ListConfig")
+                raise MissingMandatoryValue("Cannot iterate a missing ListConfig")
 
             class MyItems(Iterator[Any]):
                 def __init__(self, lst: ListConfig) -> None:
diff --git a/omegaconf/omegaconf.py b/omegaconf/omegaconf.py
index c17fc26..89a3f08 100644
--- a/omegaconf/omegaconf.py
+++ b/omegaconf/omegaconf.py
@@ -28,19 +28,20 @@ from typing_extensions import Protocol
 
 from . import DictConfig, ListConfig
 from ._utils import (
-    ValueKind,
     _get_value,
     decode_primitive,
     format_and_raise,
+    get_dict_key_value_types,
+    get_list_element_type,
     get_type_of,
-    get_value_kind,
+    is_dict_annotation,
+    is_list_annotation,
     is_primitive_container,
     is_primitive_dict,
     is_primitive_list,
     is_structured_config,
     isint,
     type_str,
-    valid_value_annotation_type,
 )
 from .base import Container, Node
 from .basecontainer import BaseContainer
@@ -196,13 +197,33 @@ class OmegaConf:
                     or is_structured_config(obj)
                     or obj is None
                 ):
-                    ref_type = OmegaConf.get_ref_type(obj)
+                    ref_type = None
+                    if is_structured_config(obj):
+                        ref_type = get_type_of(obj)
+                    elif OmegaConf.is_dict(obj):
+                        ref_type = obj._metadata.ref_type
+
                     if ref_type is None:
                         ref_type = OmegaConf.get_type(obj)
-                    return DictConfig(content=obj, parent=parent, ref_type=ref_type)
+
+                    if isinstance(obj, DictConfig):
+                        key_type = obj._metadata.key_type
+                        element_type = obj._metadata.element_type
+                    else:
+                        key_type, element_type = get_dict_key_value_types(ref_type)
+                    return DictConfig(
+                        content=obj,
+                        parent=parent,
+                        ref_type=ref_type,
+                        key_type=key_type,
+                        element_type=element_type,
+                    )
                 elif is_primitive_list(obj) or OmegaConf.is_list(obj):
                     ref_type = OmegaConf.get_type(obj)
-                    return ListConfig(ref_type=ref_type, content=obj, parent=parent)
+                    element_type = get_list_element_type(ref_type)
+                    return ListConfig(
+                        element_type=element_type, content=obj, parent=parent
+                    )
                 else:
                     if isinstance(obj, type):
                         raise ValidationError(
@@ -499,18 +520,6 @@ class OmegaConf:
         else:
             return get_type_of(c)
 
-    @staticmethod
-    def get_ref_type(obj: Any, key: Optional[str] = None) -> Optional[Type[Any]]:
-        if key is not None:
-            c = obj._get_node(key)
-        else:
-            c = obj
-
-        if isinstance(c, Node):
-            return c._metadata.ref_type
-        else:
-            return None
-
     @staticmethod
     def select(cfg: Container, key: str, throw_on_missing: bool = False) -> Any:
         try:
@@ -555,7 +564,6 @@ class OmegaConf:
 register_default_resolvers()
 
 
-# noinspection PyProtectedMember
 @contextmanager
 def flag_override(
     config: Node, name: str, value: Optional[bool]
@@ -568,7 +576,6 @@ def flag_override(
         config._set_flag(name, prev_state)
 
 
-# noinspection PyProtectedMember
 @contextmanager
 def read_write(config: Node) -> Generator[Node, None, None]:
     prev_state = config._get_node_flag("readonly")
@@ -579,7 +586,6 @@ def read_write(config: Node) -> Generator[Node, None, None]:
         OmegaConf.set_readonly(config, prev_state)
 
 
-# noinspection PyProtectedMember
 @contextmanager
 def open_dict(config: Container) -> Generator[Container, None, None]:
     prev_state = config._get_node_flag("struct")
@@ -595,14 +601,42 @@ def open_dict(config: Container) -> Generator[Container, None, None]:
 
 def _node_wrap(
     type_: Any, parent: Optional[BaseContainer], is_optional: bool, value: Any, key: Any
-) -> ValueNode:
-    if not valid_value_annotation_type(type_):
-        raise ValidationError(
-            f"Annotated class '{type_str(type_)}' is not a structured config. "
-            "did you forget to decorate it as a dataclass?"
+) -> Node:
+    node: Node
+    is_dict = type(value) is dict or is_dict_annotation(type_)
+    is_list = type(value) in (list, tuple) or is_list_annotation(type_)
+    if is_dict:
+        key_type, element_type = get_dict_key_value_types(type_)
+        node = DictConfig(
+            content=value,
+            key=key,
+            parent=parent,
+            ref_type=type_,
+            is_optional=is_optional,
+            key_type=key_type,
+            element_type=element_type,
+        )
+    elif is_list:
+        element_type = get_list_element_type(type_)
+        node = ListConfig(
+            content=value,
+            key=key,
+            parent=parent,
+            is_optional=is_optional,
+            element_type=element_type,
+        )
+    elif is_structured_config(type_):
+        key_type, element_type = get_dict_key_value_types(type_)
+        node = DictConfig(
+            ref_type=type_,
+            is_optional=is_optional,
+            content=value,
+            key=key,
+            parent=parent,
+            key_type=key_type,
+            element_type=element_type,
         )
-    node: ValueNode
-    if type_ == Any or type_ is None:
+    elif type_ == Any or type_ is None:
         node = AnyNode(value=value, key=key, parent=parent, is_optional=is_optional)
     elif issubclass(type_, Enum):
         node = EnumNode(
@@ -621,9 +655,7 @@ def _node_wrap(
     elif type_ == str:
         node = StringNode(value=value, key=key, parent=parent, is_optional=is_optional)
     else:
-        raise ValidationError(
-            f"Unexpected object type : {type_.__name__}"
-        )  # pragma: no cover
+        raise ValidationError(f"Unexpected object type : {type_str(type_)}")
     return node
 
 
@@ -634,71 +666,20 @@ def _maybe_wrap(
     is_optional: bool,
     parent: Optional[BaseContainer],
 ) -> Node:
-    from . import DictConfig, ListConfig
-
-    if isinstance(value, ValueNode):
+    # if already a node, update key and parent and return as is.
+    # NOTE: that this mutate the input node!
+    if isinstance(value, Node):
         value._set_key(key)
         value._set_parent(parent)
         return value
-    ret: Node
-    origin_ = getattr(ref_type, "__origin__", None)
-    is_dict = (
-        type(value) in (dict, DictConfig)
-        or origin_ in (dict, DictConfig)
-        or origin_ is Dict
-    )
-    is_list = (
-        type(value) in (list, tuple, ListConfig)
-        or origin_ in (list, tuple, ListConfig)
-        or origin_ is List
-    )
-    value_kind = get_value_kind(value)
-
-    if is_dict:
-        ret = DictConfig(
-            content=value,
-            key=key,
-            parent=parent,
-            ref_type=ref_type,
-            is_optional=is_optional,
-        )
-    elif is_list:
-
-        ret = ListConfig(
-            content=value,
-            key=key,
-            parent=parent,
-            is_optional=is_optional,
-            ref_type=ref_type,
-        )
-    elif (
-        is_structured_config(ref_type)
-        and (
-            is_structured_config(value)
-            or value_kind == ValueKind.MANDATORY_MISSING
-            or value_kind == ValueKind.INTERPOLATION
-            or value is None
-        )
-    ) or is_structured_config(ref_type):
-        from . import DictConfig
-
-        ret = DictConfig(
-            ref_type=ref_type,
-            is_optional=is_optional,
-            content=value,
-            key=key,
-            parent=parent,
-        )
     else:
-        ret = _node_wrap(
+        return _node_wrap(
             type_=ref_type,
             parent=parent,
             is_optional=is_optional,
             value=value,
             key=key,
         )
-    assert isinstance(ret, Node)
-    return ret
 
 
 def _select_one(

More informative OmegaConf.get_ref_type
try to return Dict[K, V] and List[T] for DictConfig (unstructured) and ListConfig
diff --git a/tests/structured_conf/test_structured_basic.py b/tests/structured_conf/test_structured_basic.py
index e6e59ca..77c5443 100644
--- a/tests/structured_conf/test_structured_basic.py
+++ b/tests/structured_conf/test_structured_basic.py
@@ -1,10 +1,10 @@
 import re
 from importlib import import_module
-from typing import Any
+from typing import Any, Optional
 
 import pytest
 
-from omegaconf import OmegaConf, ValidationError
+from omegaconf import OmegaConf, ValidationError, _utils
 from omegaconf.errors import ConfigKeyError
 
 
@@ -26,7 +26,10 @@ class TestStructured:
             self, class_type: str
         ) -> None:
             module: Any = import_module(class_type)
-            with pytest.raises(ValidationError, match="structured config"):
+            with pytest.raises(
+                ValidationError,
+                match=re.escape("Unexpected object type : NotStructuredConfig"),
+            ):
                 OmegaConf.structured(module.StructuredWithInvalidField)
 
         def test_assignment_of_subclass(self, class_type: str) -> None:
@@ -117,7 +120,7 @@ class TestStructured:
         module: Any = import_module(class_type)
         cfg1 = OmegaConf.create(module.LinkedList)
         assert OmegaConf.get_type(cfg1) == module.LinkedList
-        assert OmegaConf.get_ref_type(cfg1, "next") == module.LinkedList
+        assert _utils.get_ref_type(cfg1, "next") == Optional[module.LinkedList]
         assert OmegaConf.get_type(cfg1, "next") is None
 
         assert cfg1.next is None
@@ -125,7 +128,7 @@ class TestStructured:
 
         cfg2 = OmegaConf.create(module.MissingTest.Missing1)
         assert OmegaConf.is_missing(cfg2, "head")
-        assert OmegaConf.get_ref_type(cfg2, "head") == module.LinkedList
+        assert _utils.get_ref_type(cfg2, "head") == module.LinkedList
         assert OmegaConf.get_type(cfg2, "head") is None
 
     class TestMissing:
@@ -151,19 +154,26 @@ class TestStructured:
         def test_plugin_holder(self, class_type: str) -> None:
             module: Any = import_module(class_type)
             cfg = OmegaConf.create(module.PluginHolder)
-            assert OmegaConf.get_ref_type(cfg, "none") == module.Plugin
+
+            assert OmegaConf.is_optional(cfg, "none")
+            assert _utils.get_ref_type(cfg, "none") == Optional[module.Plugin]
             assert OmegaConf.get_type(cfg, "none") is None
 
-            assert OmegaConf.get_ref_type(cfg, "missing") == module.Plugin
+            assert not OmegaConf.is_optional(cfg, "missing")
+            assert _utils.get_ref_type(cfg, "missing") == module.Plugin
             assert OmegaConf.get_type(cfg, "missing") is None
 
-            assert OmegaConf.get_ref_type(cfg, "plugin") == module.Plugin
+            assert not OmegaConf.is_optional(cfg, "plugin")
+            assert _utils.get_ref_type(cfg, "plugin") == module.Plugin
             assert OmegaConf.get_type(cfg, "plugin") == module.Plugin
+
             cfg.plugin = module.ConcretePlugin()
-            assert OmegaConf.get_ref_type(cfg, "plugin") == module.Plugin
+            assert not OmegaConf.is_optional(cfg, "plugin")
+            assert _utils.get_ref_type(cfg, "plugin") == module.Plugin
             assert OmegaConf.get_type(cfg, "plugin") == module.ConcretePlugin
 
-            assert OmegaConf.get_ref_type(cfg, "plugin2") == module.Plugin
+            assert not OmegaConf.is_optional(cfg, "plugin2")
+            assert _utils.get_ref_type(cfg, "plugin2") == module.Plugin
             assert OmegaConf.get_type(cfg, "plugin2") == module.ConcretePlugin
 
         def test_native_missing(self, class_type: str) -> None:
diff --git a/tests/structured_conf/test_structured_config.py b/tests/structured_conf/test_structured_config.py
index bdfb843..2e544de 100644
--- a/tests/structured_conf/test_structured_config.py
+++ b/tests/structured_conf/test_structured_config.py
@@ -1,6 +1,6 @@
 import re
 from importlib import import_module
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 import pytest
 
@@ -13,6 +13,7 @@ from omegaconf import (
     OmegaConf,
     ReadonlyConfigError,
     ValidationError,
+    _utils,
 )
 from tests import Color
 
@@ -96,7 +97,7 @@ class TestConfigs:
         cfg = OmegaConf.structured(module.NestedWithNone)
         assert cfg == {"plugin": None}
         assert OmegaConf.get_type(cfg, "plugin") is None
-        assert OmegaConf.get_ref_type(cfg, "plugin") == module.Plugin
+        assert _utils.get_ref_type(cfg, "plugin") == Optional[module.Plugin]
 
     def test_nested_config(self, class_type: str) -> None:
         module: Any = import_module(class_type)
@@ -450,11 +451,11 @@ class TestConfigs:
     def test_merge_with_subclass_into_missing(self, class_type: str) -> None:
         module: Any = import_module(class_type)
         base = OmegaConf.structured(module.PluginHolder)
-        assert OmegaConf.get_ref_type(base, "missing") == module.Plugin
+        assert _utils.get_ref_type(base, "missing") == module.Plugin
         assert OmegaConf.get_type(base, "missing") is None
         res = OmegaConf.merge(base, {"missing": module.Plugin})
         assert OmegaConf.get_type(res) == module.PluginHolder
-        assert OmegaConf.get_ref_type(base, "missing") == module.Plugin
+        assert _utils.get_ref_type(base, "missing") == module.Plugin
         assert OmegaConf.get_type(res, "missing") == module.Plugin
 
     def test_merged_with_nons_subclass(self, class_type: str) -> None:
@@ -709,6 +710,18 @@ class TestDictSubclass:
         with pytest.raises(KeyValidationError):
             cfg[Color.RED] = "fail"
 
+    def test_str2str_as_sub_node(self, class_type: str) -> None:
+        module: Any = import_module(class_type)
+        cfg = OmegaConf.create({"foo": module.DictSubclass.Str2Str})
+        assert OmegaConf.get_type(cfg.foo) == module.DictSubclass.Str2Str
+        assert _utils.get_ref_type(cfg.foo) == Optional[module.DictSubclass.Str2Str]
+
+        cfg.foo.hello = "world"
+        assert cfg.foo.hello == "world"
+
+        with pytest.raises(KeyValidationError):
+            cfg.foo[Color.RED] = "fail"
+
     def test_color2str(self, class_type: str) -> None:
         module: Any = import_module(class_type)
         cfg = OmegaConf.structured(module.DictSubclass.Color2Str())
diff --git a/tests/test_base_config.py b/tests/test_base_config.py
index a0c6a0d..d049f67 100644
--- a/tests/test_base_config.py
+++ b/tests/test_base_config.py
@@ -85,10 +85,10 @@ def test_replace_value_node_type_with_another(
     "input_",
     [
         [1, 2, 3],
-        [1, 2, dict(a=3)],
+        [1, 2, {"a": 3}],
         [1, 2, [10, 20]],
-        dict(b=dict(b=10)),
-        dict(b=[1, 2, 3]),
+        {"b": {"b": 10}},
+        {"b": [1, 2, 3]},
     ],
 )
 def test_to_container_returns_primitives(input_: Any) -> None:
@@ -258,7 +258,7 @@ def test_deepcopy_and_merge_and_flags() -> None:
 
 
 @pytest.mark.parametrize(  # type: ignore
-    "cfg", [ListConfig(ref_type=List[int], content=[]), DictConfig(content={})],
+    "cfg", [ListConfig(element_type=int, content=[]), DictConfig(content={})],
 )
 def test_deepcopy_preserves_container_type(cfg: Container) -> None:
     cp: Container = copy.deepcopy(cfg)
diff --git a/tests/test_basic_ops_dict.py b/tests/test_basic_ops_dict.py
index 849d578..6efd0b1 100644
--- a/tests/test_basic_ops_dict.py
+++ b/tests/test_basic_ops_dict.py
@@ -12,6 +12,7 @@ from omegaconf import (
     OmegaConf,
     UnsupportedValueType,
     ValidationError,
+    _utils,
 )
 from omegaconf.basecontainer import BaseContainer
 from omegaconf.errors import KeyValidationError
@@ -569,13 +570,29 @@ def test_get_type() -> None:
     assert OmegaConf.get_type(cfg.inter) == User
 
 
-def test_get_ref_type() -> None:
-    cfg = OmegaConf.create(
-        {"plugin": DictConfig(ref_type=Plugin, content=ConcretePlugin)}
-    )
-
-    assert OmegaConf.get_type(cfg.plugin) == ConcretePlugin
-    assert OmegaConf.get_ref_type(cfg.plugin) == Plugin
+@pytest.mark.parametrize(  # type: ignore
+    "cfg, expected_ref_type",
+    [
+        (
+            OmegaConf.create(
+                {"plugin": DictConfig(ref_type=Plugin, content=ConcretePlugin)}
+            ),
+            Optional[Plugin],
+        ),
+        (
+            OmegaConf.create(
+                {
+                    "plugin": DictConfig(
+                        ref_type=Plugin, content=ConcretePlugin, is_optional=False
+                    )
+                }
+            ),
+            Plugin,
+        ),
+    ],
+)
+def test_get_ref_type(cfg: Any, expected_ref_type: Any) -> None:
+    assert _utils.get_ref_type(cfg.plugin) == expected_ref_type
 
 
 def test_get_ref_type_with_conflict() -> None:
@@ -584,11 +601,11 @@ def test_get_ref_type_with_conflict() -> None:
     )
 
     assert OmegaConf.get_type(cfg.user) == User
-    assert OmegaConf.get_ref_type(cfg.user) == User
+    assert _utils.get_ref_type(cfg.user) == Optional[User]
 
     # Interpolation inherits both type and ref type from the target
     assert OmegaConf.get_type(cfg.inter) == User
-    assert OmegaConf.get_ref_type(cfg.inter) == User
+    assert _utils.get_ref_type(cfg.inter) == Optional[User]
 
 
 def test_is_missing() -> None:
@@ -658,11 +675,11 @@ def test_assign_to_reftype_plugin(
     for value in values:
         cfg = OmegaConf.create({"foo": DictConfig(ref_type=ref_type, content=value)})
         with expectation():
-            assert OmegaConf.get_ref_type(cfg, "foo") == ref_type
+            assert _utils.get_ref_type(cfg, "foo") == Optional[ref_type]
             cfg.foo = assign
             assert cfg.foo == assign
             # validate assignment does not change ref type.
-            assert OmegaConf.get_ref_type(cfg, "foo") == ref_type
+            assert _utils.get_ref_type(cfg, "foo") == Optional[ref_type]
 
         if value is not None:
             cfg = OmegaConf.create(
diff --git a/tests/test_basic_ops_list.py b/tests/test_basic_ops_list.py
index b6ef7e2..b341290 100644
--- a/tests/test_basic_ops_list.py
+++ b/tests/test_basic_ops_list.py
@@ -274,7 +274,7 @@ def validate_list_keys(c: Any) -> None:
             None,
         ),
         (
-            ListConfig(ref_type=List[int], content=[]),
+            ListConfig(element_type=int, content=[]),
             0,
             "foo",
             None,
diff --git a/tests/test_create.py b/tests/test_create.py
index 16718ac..8e06e4e 100644
--- a/tests/test_create.py
+++ b/tests/test_create.py
@@ -126,7 +126,7 @@ def test_create_from_dictconfig_preserves_metadata() -> None:
 
 
 def test_create_from_listconfig_preserves_metadata() -> None:
-    cfg1 = ListConfig(ref_type=List[int], is_optional=False, content=[1, 2, 3])
+    cfg1 = ListConfig(element_type=int, is_optional=False, content=[1, 2, 3])
     OmegaConf.set_struct(cfg1, True)
     OmegaConf.set_readonly(cfg1, True)
     cfg2 = OmegaConf.create(cfg1)
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 2649724..2ada2b0 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -14,7 +14,6 @@ from omegaconf import (
     UnsupportedValueType,
     ValidationError,
 )
-from omegaconf._utils import type_str
 from omegaconf.errors import (
     ConfigAttributeError,
     ConfigKeyError,
@@ -45,12 +44,15 @@ class Expected:
     key: Any = None
     # "AUTO" : determine automatically based on OmegaConf.get_type(cfg)
     object_type: Any = "AUTO"
+    ref_type: Any = None
+
     # "AUTO: full_key is key
     full_key: Any = "AUTO"
     create: Any = lambda: None
     op: Any = lambda _cfg: None
     child_node: Any = lambda cfg: None
     parent_node: Any = lambda cfg: cfg
+
     object_type_str: Optional[str] = "AUTO"
     ref_type_str: Optional[str] = "AUTO"
     num_lines: int = 4
@@ -68,24 +70,6 @@ class Expected:
                 else:
                     self.full_key = ""
 
-        parent = self.parent_node(cfg)
-        if self.object_type_str == "AUTO":
-            parent_type = OmegaConf.get_type(parent)
-            if parent_type is not None:
-                self.object_type_str = type_str(parent_type)
-            else:
-                self.object_type_str = "Any"
-
-        if self.ref_type_str == "AUTO":
-            parent_type = OmegaConf.get_ref_type(parent)
-            if parent_type is not None:
-                self.ref_type_str = type_str(parent_type)
-                if parent._is_optional():
-                    self.ref_type_str = f"Optional[{self.ref_type_str}]"
-
-            else:
-                self.ref_type_str = "Any"
-
 
 params = [
     ##############
@@ -101,6 +85,7 @@ params = [
             parent_node=lambda cfg: cfg,
             child_node=lambda cfg: cfg._get_node("num"),
             object_type=StructuredWithMissing,
+            ref_type=Optional[StructuredWithMissing],
             key="num",
         ),
         id="structured:update_with_invalid_value",
@@ -114,6 +99,7 @@ params = [
             parent_node=lambda cfg: cfg,
             child_node=lambda cfg: cfg._get_node("num"),
             object_type=StructuredWithMissing,
+            ref_type=Optional[StructuredWithMissing],
             key="num",
         ),
         id="structured:update:none_to_non_optional",
@@ -124,6 +110,7 @@ params = [
             op=lambda cfg: OmegaConf.update(cfg, "a", IllegalType()),
             key="a",
             exception_type=UnsupportedValueType,
+            ref_type=Optional[Dict[Any, Any]],
             msg="Value 'IllegalType' is not a supported primitive type",
         ),
         id="dict:update:object_of_illegal_type",
@@ -136,6 +123,7 @@ params = [
             key="foo",
             child_node=lambda cfg: cfg._get_node("foo"),
             exception_type=ReadonlyConfigError,
+            ref_type=Optional[Dict[Any, Any]],
             msg="Cannot pop from read-only node",
         ),
         id="dict,readonly:pop",
@@ -170,6 +158,7 @@ params = [
             msg="Key 'fail' not in 'ConcretePlugin'",
             key="fail",
             object_type=ConcretePlugin,
+            ref_type=Optional[ConcretePlugin],
         ),
         id="structured:access_invalid_attribute",
     ),
@@ -225,6 +214,7 @@ params = [
             msg="Invalid type assigned : int is not a subclass of FoobarParams. value: 20",
             key="params",
             object_type=ConcretePlugin,
+            ref_type=Optional[ConcretePlugin],
             child_node=lambda cfg: cfg.params,
         ),
         id="structured:setattr,invalid_type_assigned_to_structured",
@@ -249,9 +239,10 @@ params = [
             exception_type=ValidationError,
             msg="field 'foo' is not Optional",
             key="foo",
+            full_key="foo",
             child_node=lambda cfg: cfg.foo,
         ),
-        id="dict,none_optional:set_none",
+        id="dict,not_optional:set_none",
     ),
     pytest.param(
         Expected(
@@ -291,25 +282,25 @@ params = [
     ),
     pytest.param(
         Expected(
-            create=lambda: DictConfig(ref_type=Dict[Color, str], content={}),
+            create=lambda: DictConfig(key_type=Color, element_type=str, content={}),
             op=lambda cfg: cfg.__getitem__("foo"),
             exception_type=KeyValidationError,
             msg="Key 'foo' is incompatible with (Color)",
             key="foo",
             num_lines=7,
         ),
-        id="dict,reftype=Dict[Color,str]:,getitem_str_key",
+        id="DictConfig[Color,str]:getitem_str_key",
     ),
     pytest.param(
         Expected(
-            create=lambda: DictConfig(ref_type=Dict[str, str], content={}),
+            create=lambda: DictConfig(key_type=str, element_type=str, content={}),
             op=lambda cfg: cfg.__getitem__(Color.RED),
             exception_type=KeyValidationError,
             msg="Key Color.RED (Color) is incompatible with (str)",
             full_key="RED",
             key=Color.RED,
         ),
-        id="dict,reftype=Dict[str,str]:,getitem_color_key",
+        id="DictConfig[str,str]:getitem_color_key",
     ),
     # merge
     pytest.param(
@@ -435,20 +426,22 @@ params = [
             exception_type=ValidationError,
             msg="Invalid type assigned : int is not a subclass of ConcretePlugin. value: 1",
             low_level=True,
+            ref_type=Optional[ConcretePlugin],
         ),
         id="dict:set_value:reftype_mismatch",
     ),
     pytest.param(
         Expected(
             create=lambda: DictConfig(
-                ref_type=Dict[str, int], content={"foo": 10, "bar": 20}
+                key_type=str, element_type=int, content={"foo": 10, "bar": 20}
             ),
             op=lambda cfg: cfg.__setitem__("baz", "fail"),
             exception_type=ValidationError,
             msg="Value 'fail' could not be converted to Integer",
             key="baz",
+            ref_type=Optional[Dict[str, int]],
         ),
-        id="dict,int_element_type:assigned_str_value",
+        id="DictConfig[str,int]:assigned_str_value",
     ),
     # delete
     pytest.param(
@@ -477,7 +470,7 @@ params = [
         ),
         id="list:setattr",
     ),
-    # # setattr
+    # setattr
     pytest.param(
         Expected(
             create=lambda: OmegaConf.create([1, 2, 3]),
@@ -498,6 +491,7 @@ params = [
             key="foo",
             full_key="[foo]",
             msg="ListConfig indices must be integers or slices, not str",
+            ref_type=Optional[List[Any]],
         ),
         id="list:get_nox_ex:invalid_index_type",
     ),
@@ -520,6 +514,7 @@ params = [
             msg="Cannot get_node from a ListConfig object representing None",
             key=20,
             full_key="[20]",
+            ref_type=Optional[List[Any]],
         ),
         id="list:get_node_none",
     ),
@@ -698,16 +693,30 @@ params = [
         ),
         id="list,readonly:setitem",
     ),
+    # _set_value
+    pytest.param(
+        Expected(
+            create=lambda: ListConfig(is_optional=False, element_type=int, content=[]),
+            op=lambda cfg: cfg._set_value(None),
+            exception_type=ValidationError,
+            object_type=None,
+            msg="Non optional ListConfig cannot be constructed from None",
+            ref_type=List[int],
+            low_level=True,
+        ),
+        id="list:create_not_optional:_set_value(None)",
+    ),
     # assign
     pytest.param(
         Expected(
-            create=lambda: ListConfig(ref_type=List[int], content=[1, 2, 3]),
+            create=lambda: ListConfig(element_type=int, content=[1, 2, 3]),
             op=lambda cfg: cfg.__setitem__(0, "foo"),
             exception_type=ValidationError,
             msg="Value 'foo' could not be converted to Integer",
             key=0,
             full_key="[0]",
             child_node=lambda cfg: cfg[0],
+            ref_type=Optional[List[int]],
         ),
         id="list,int_elements:assigned_str_element",
     ),
@@ -715,7 +724,7 @@ params = [
         Expected(
             # make sure OmegaConf.create is not losing critical metadata.
             create=lambda: OmegaConf.create(
-                ListConfig(ref_type=List[int], content=[1, 2, 3])
+                ListConfig(element_type=int, content=[1, 2, 3])
             ),
             op=lambda cfg: cfg.__setitem__(0, "foo"),
             exception_type=ValidationError,
@@ -723,6 +732,7 @@ params = [
             key=0,
             full_key="[0]",
             child_node=lambda cfg: cfg[0],
+            ref_type=Optional[List[int]],
         ),
         id="list,int_elements:assigned_str_element",
     ),
@@ -737,6 +747,7 @@ params = [
             key=0,
             full_key="[0]",
             child_node=lambda cfg: cfg[0],
+            ref_type=Optional[List[Any]],
         ),
         id="list,not_optional:null_assignment",
     ),
@@ -783,6 +794,7 @@ params = [
             key=1,
             full_key="[1]",
             child_node=lambda _cfg: None,
+            ref_type=Optional[List[Any]],
         ),
         id="list:insert_into_missing",
     ),
@@ -795,6 +807,7 @@ params = [
             msg="Cannot get from a ListConfig object representing None",
             key=0,
             full_key="[0]",
+            ref_type=Optional[List[Any]],
         ),
         id="list:get_from_none",
     ),
@@ -852,7 +865,7 @@ params = [
             create=lambda: ListConfig(content=None),
             op=lambda cfg: iter(cfg),
             exception_type=TypeError,
-            msg="Cannot iterate on ListConfig object representing None",
+            msg="Cannot iterate a ListConfig object representing None",
         ),
         id="list:iter_none",
     ),
@@ -861,7 +874,7 @@ params = [
             create=lambda: ListConfig(content="???"),
             op=lambda cfg: iter(cfg),
             exception_type=MissingMandatoryValue,
-            msg="Cannot iterate on a missing ListConfig",
+            msg="Cannot iterate a missing ListConfig",
         ),
         id="list:iter_missing",
     ),
@@ -908,9 +921,9 @@ def test_errors(expected: Expected, monkeypatch: Any) -> None:
     with pytest.raises(expected.exception_type, match=re.escape(msg)) as einfo:
         try:
             expected.op(cfg)
-        except Exception:
+        except Exception as e:
             # helps in debugging
-            raise
+            raise e
     ex = einfo.value
 
     assert ex.object_type == expected.object_type
@@ -922,8 +935,12 @@ def test_errors(expected: Expected, monkeypatch: Any) -> None:
         assert ex.child_node == expected.child_node(cfg)
         assert ex.full_key == expected.full_key
         assert isinstance(expected.full_key, str)
-        assert ex.object_type_str == expected.object_type_str
-        assert ex.ref_type_str == expected.ref_type_str
+
+        if expected.ref_type is not None:
+            assert ex.ref_type == expected.ref_type
+
+        if expected.object_type is not None:
+            assert ex.object_type == expected.object_type
 
         with monkeypatch.context() as m:
             m.setenv("OC_CAUSE", "1")
diff --git a/tests/test_get_full_key.py b/tests/test_get_full_key.py
index e7058e0..1aef2a1 100644
--- a/tests/test_get_full_key.py
+++ b/tests/test_get_full_key.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -73,14 +73,18 @@ from . import Color
         ({"foo": {"bar": IntegerNode(value=10)}}, "foo", "bar", "foo.bar"),
         # enum
         pytest.param(
-            DictConfig(ref_type=Dict[Color, str], content={Color.RED: "red"}),
+            DictConfig(key_type=Color, element_type=str, content={Color.RED: "red"}),
             "RED",
             "",
             "RED",
             id="get_full_key_with_enum_key",
         ),
         pytest.param(
-            {"foo": DictConfig(ref_type=Dict[Color, str], content={Color.RED: "red"})},
+            {
+                "foo": DictConfig(
+                    key_type=Color, element_type=str, content={Color.RED: "red"}
+                )
+            },
             "foo",
             "RED",
             "foo.RED",
diff --git a/tests/test_omegaconf.py b/tests/test_omegaconf.py
index e37e0a9..eb39622 100644
--- a/tests/test_omegaconf.py
+++ b/tests/test_omegaconf.py
@@ -17,14 +17,7 @@ from omegaconf import (
 )
 from omegaconf.errors import UnsupportedInterpolationType
 
-from . import (
-    Color,
-    ConcretePlugin,
-    IllegalType,
-    Plugin,
-    StructuredWithMissing,
-    does_not_raise,
-)
+from . import Color, ConcretePlugin, IllegalType, StructuredWithMissing, does_not_raise
 
 
 @pytest.mark.parametrize(  # type: ignore
@@ -384,36 +377,6 @@ def test_get_type_on_raw(obj: Any, type_: Any) -> None:
     assert OmegaConf.get_type(obj) == type_
 
 
-@pytest.mark.parametrize(  # type: ignore
-    "cfg, type_",
-    [
-        ({}, None),  # missing foo key
-        ({"foo": 10}, None),
-        ({"foo": 10.0}, None),
-        ({"foo": True}, None),
-        ({"foo": "bar"}, None),
-        ({"foo": None}, None),
-        ({"foo": IntegerNode(10)}, int),
-        ({"foo": FloatNode(10.0)}, float),
-        ({"foo": BooleanNode(True)}, bool),
-        ({"foo": StringNode("bar")}, str),
-        ({"foo": EnumNode(enum_type=Color, value=Color.RED)}, Color),
-        ({"foo": ConcretePlugin()}, ConcretePlugin),
-        ({"foo": ConcretePlugin}, ConcretePlugin),
-        ({"foo": DictConfig(ref_type=Plugin, content=ConcretePlugin)}, Plugin),
-        ({"foo": {}}, None),
-        pytest.param(
-            {"foo": OmegaConf.create()}, dict, id="create_with_nested_dictconfig"
-        ),
-        ({"foo": []}, None),
-        ({"foo": OmegaConf.create([])}, list),
-    ],
-)
-def test_get_ref_type(cfg: Any, type_: Any) -> None:
-    cfg = OmegaConf.create(cfg)
-    assert OmegaConf.get_ref_type(cfg, "foo") == type_
-
-
 def test_is_issubclass() -> None:
     cfg = OmegaConf.structured(ConcretePlugin)
     t = OmegaConf.get_type(cfg)
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 06ede88..275f21b 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,76 +1,105 @@
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 import attr
 import pytest
 
-from omegaconf import DictConfig, ListConfig, OmegaConf, _utils
+from omegaconf import DictConfig, ListConfig, Node, OmegaConf, _utils
+from omegaconf._utils import is_dict_annotation, is_list_annotation
 from omegaconf.errors import KeyValidationError, ValidationError
-from omegaconf.nodes import StringNode
+from omegaconf.nodes import (
+    AnyNode,
+    BooleanNode,
+    EnumNode,
+    FloatNode,
+    IntegerNode,
+    StringNode,
+)
+from omegaconf.omegaconf import _node_wrap
 
-from . import Color, IllegalType, Plugin, does_not_raise
+from . import Color, ConcretePlugin, IllegalType, Plugin, does_not_raise
 
 
 @pytest.mark.parametrize(  # type: ignore
-    "target_type, value, expectation",
+    "target_type, value, expected",
     [
         # Any
-        (Any, "foo", None),
-        (Any, True, None),
-        (Any, 1, None),
-        (Any, 1.0, None),
-        (Any, Color.RED, None),
+        pytest.param(Any, "foo", AnyNode("foo"), id="any"),
+        pytest.param(Any, True, AnyNode(True), id="any"),
+        pytest.param(Any, 1, AnyNode(1), id="any"),
+        pytest.param(Any, 1.0, AnyNode(1.0), id="any"),
+        pytest.param(Any, Color.RED, AnyNode(Color.RED), id="any"),
+        pytest.param(Any, {}, DictConfig(content={}), id="any_as_dict"),
+        pytest.param(Any, [], ListConfig(content=[]), id="any_as_list"),
         # int
-        (int, "foo", ValidationError),
-        (int, True, ValidationError),
-        (int, 1, None),
-        (int, 1.0, ValidationError),
-        (int, Color.RED, ValidationError),
+        pytest.param(int, "foo", ValidationError, id="int"),
+        pytest.param(int, True, ValidationError, id="int"),
+        pytest.param(int, 1, IntegerNode(1), id="int"),
+        pytest.param(int, 1.0, ValidationError, id="int"),
+        pytest.param(int, Color.RED, ValidationError, id="int"),
         # float
-        (float, "foo", ValidationError),
-        (float, True, ValidationError),
-        (float, 1, None),
-        (float, 1.0, None),
-        (float, Color.RED, ValidationError),
-        # bool
-        (bool, "foo", ValidationError),
-        (bool, True, None),
-        (bool, 1, None),
-        (bool, 0, None),
-        (bool, 1.0, ValidationError),
-        (bool, Color.RED, ValidationError),
-        (bool, "true", None),
-        (bool, "false", None),
-        (bool, "on", None),
-        (bool, "off", None),
+        pytest.param(float, "foo", ValidationError, id="float"),
+        pytest.param(float, True, ValidationError, id="float"),
+        pytest.param(float, 1, FloatNode(1), id="float"),
+        pytest.param(float, 1.0, FloatNode(1.0), id="float"),
+        pytest.param(float, Color.RED, ValidationError, id="float"),
+        # # bool
+        pytest.param(bool, "foo", ValidationError, id="bool"),
+        pytest.param(bool, True, BooleanNode(True), id="bool"),
+        pytest.param(bool, 1, BooleanNode(True), id="bool"),
+        pytest.param(bool, 0, BooleanNode(False), id="bool"),
+        pytest.param(bool, 1.0, ValidationError, id="bool"),
+        pytest.param(bool, Color.RED, ValidationError, id="bool"),
+        pytest.param(bool, "true", BooleanNode(True), id="bool"),
+        pytest.param(bool, "false", BooleanNode(False), id="bool"),
+        pytest.param(bool, "on", BooleanNode(True), id="bool"),
+        pytest.param(bool, "off", BooleanNode(False), id="bool"),
         # str
-        (str, "foo", None),
-        (str, True, None),
-        (str, 1, None),
-        (str, 1.0, None),
-        (str, Color.RED, None),
+        pytest.param(str, "foo", StringNode("foo"), id="str"),
+        pytest.param(str, True, StringNode("True"), id="str"),
+        pytest.param(str, 1, StringNode("1"), id="str"),
+        pytest.param(str, 1.0, StringNode("1.0"), id="str"),
+        pytest.param(str, Color.RED, StringNode("Color.RED"), id="str"),
         # Color
-        (Color, "foo", ValidationError),
-        (Color, True, ValidationError),
-        (Color, 1, None),
-        (Color, 1.0, ValidationError),
-        (Color, Color.RED, None),
-        (Color, "RED", None),
-        (Color, "Color.RED", None),
+        pytest.param(Color, "foo", ValidationError, id="Color"),
+        pytest.param(Color, True, ValidationError, id="Color"),
+        pytest.param(Color, 1, EnumNode(enum_type=Color, value=Color.RED), id="Color"),
+        pytest.param(Color, 1.0, ValidationError, id="Color"),
+        pytest.param(
+            Color, Color.RED, EnumNode(enum_type=Color, value=Color.RED), id="Color"
+        ),
+        pytest.param(
+            Color, "RED", EnumNode(enum_type=Color, value=Color.RED), id="Color"
+        ),
+        pytest.param(
+            Color, "Color.RED", EnumNode(enum_type=Color, value=Color.RED), id="Color"
+        ),
         # bad type
-        (IllegalType, "nope", ValidationError),
+        pytest.param(IllegalType, "nope", ValidationError, id="bad_type"),
+        # DictConfig
+        pytest.param(
+            dict, {"foo": "bar"}, DictConfig(content={"foo": "bar"}), id="DictConfig"
+        ),
+        pytest.param(
+            Plugin, Plugin(), DictConfig(content=Plugin()), id="DictConfig[Plugin]"
+        ),
+        # ListConfig
+        pytest.param(list, [1, 2, 3], ListConfig(content=[1, 2, 3]), id="ListConfig"),
     ],
 )
-def test_maybe_wrap(target_type: type, value: Any, expectation: Any) -> None:
+def test_node_wrap(target_type: Any, value: Any, expected: Any) -> None:
     from omegaconf.omegaconf import _maybe_wrap
 
-    if expectation is None:
-        _maybe_wrap(
-            ref_type=target_type, key=None, value=value, is_optional=False, parent=None,
+    if isinstance(expected, Node):
+        res = _node_wrap(
+            type_=target_type, key="foo", value=value, is_optional=False, parent=None,
         )
+        assert type(res) == type(expected)
+        assert res == expected
+        assert res._key() == "foo"
     else:
-        with pytest.raises(expectation):
+        with pytest.raises(expected):
             _maybe_wrap(
                 ref_type=target_type,
                 key=None,
@@ -295,6 +324,7 @@ def test_is_primitive_type(type_: Any, is_primitive: bool) -> None:
     assert _utils.is_primitive_type(type_) == is_primitive
 
 
+@pytest.mark.parametrize("optional", [False, True])  # type: ignore
 @pytest.mark.parametrize(  # type: ignore
     "type_, expected",
     [
@@ -312,8 +342,142 @@ def test_is_primitive_type(type_: Any, is_primitive: bool) -> None:
         (List[str], "List[str]"),
         (List[Color], "List[Color]"),
         (List[Dict[str, Color]], "List[Dict[str, Color]]"),
+    ],
+)
+def test_type_str(type_: Any, expected: str, optional: bool) -> None:
+    if optional:
+        assert _utils.type_str(Optional[type_]) == f"Optional[{expected}]"
+    else:
+        assert _utils.type_str(type_) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "type_, expected",
+    [
+        (Optional[int], "Optional[int]"),
         (Union[str, int, Color], "Union[str, int, Color]"),
+        (Optional[Union[int]], "Optional[int]"),
+        (Optional[Union[int, str]], "Union[int, str, NoneType]"),
     ],
 )
-def test_type_str(type_: Any, expected: str) -> None:
+def test_type_str_union(type_: Any, expected: str) -> None:
     assert _utils.type_str(type_) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "type_, expected",
+    [
+        (Dict[str, int], True),
+        (Dict[str, float], True),
+        (Dict[IllegalType, bool], True),
+        (Dict[str, IllegalType], True),
+        (Dict[int, Color], True),
+        (Dict[Plugin, Plugin], True),
+        (Dict[IllegalType, int], True),
+        (Dict, True),
+        (List, False),
+        (dict, False),
+        (DictConfig, False),
+    ],
+)
+def test_is_dict_annotation(type_: Any, expected: Any) -> Any:
+    assert is_dict_annotation(type_=type_) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "type_, expected",
+    [
+        (List[int], True),
+        (List[float], True),
+        (List[bool], True),
+        (List[str], True),
+        (List[Color], True),
+        (List[Plugin], True),
+        (List[IllegalType], True),
+        (Dict, False),
+        (List, True),
+        (list, False),
+        (tuple, False),
+        (ListConfig, False),
+    ],
+)
+def test_is_list_annotation(type_: Any, expected: Any) -> Any:
+    assert is_list_annotation(type_=type_) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "obj, expected",
+    [
+        # Unwrapped values
+        pytest.param(10, Optional[int], id="int"),
+        pytest.param(10.0, Optional[float], id="float"),
+        pytest.param(True, Optional[bool], id="bool"),
+        pytest.param("bar", Optional[str], id="str"),
+        pytest.param(None, type(None), id="NoneType"),
+        pytest.param({}, Optional[Dict[Any, Any]], id="dict"),
+        pytest.param([], Optional[List[Any]], id="List[Any]"),
+        pytest.param(tuple(), Optional[List[Any]], id="List[Any]"),
+        pytest.param(ConcretePlugin(), Optional[ConcretePlugin], id="ConcretePlugin"),
+        pytest.param(ConcretePlugin, Optional[ConcretePlugin], id="ConcretePlugin"),
+        # Optional value nodes
+        pytest.param(IntegerNode(10), Optional[int], id="IntegerNode"),
+        pytest.param(FloatNode(10.0), Optional[float], id="FloatNode"),
+        pytest.param(BooleanNode(True), Optional[bool], id="BooleanNode"),
+        pytest.param(StringNode("bar"), Optional[str], id="StringNode"),
+        pytest.param(
+            EnumNode(enum_type=Color, value=Color.RED),
+            Optional[Color],
+            id="EnumNode[Color]",
+        ),
+        # Non-optional value nodes:
+        pytest.param(IntegerNode(10, is_optional=False), int, id="IntegerNode"),
+        pytest.param(FloatNode(10.0, is_optional=False), float, id="FloatNode"),
+        pytest.param(BooleanNode(True, is_optional=False), bool, id="BooleanNode"),
+        pytest.param(StringNode("bar", is_optional=False), str, id="StringNode"),
+        pytest.param(
+            EnumNode(enum_type=Color, value=Color.RED, is_optional=False),
+            Color,
+            id="EnumNode[Color]",
+        ),
+        # DictConfig
+        pytest.param(DictConfig(content={}), Optional[Dict[Any, Any]], id="DictConfig"),
+        pytest.param(
+            DictConfig(key_type=int, element_type=Color, content={}),
+            Optional[Dict[int, Color]],
+            id="DictConfig[int,Color]",
+        ),
+        pytest.param(
+            DictConfig(key_type=Color, element_type=int, content={}),
+            Optional[Dict[Color, int]],
+            id="DictConfig[Color,int]",
+        ),
+        pytest.param(
+            DictConfig(ref_type=Any, content=ConcretePlugin),
+            Any,
+            id="DictConfig[ConcretePlugin]_Any_reftype",
+        ),
+        pytest.param(
+            DictConfig(ref_type=Plugin, content=ConcretePlugin),
+            Optional[Plugin],
+            id="DictConfig[Plugin]",
+        ),
+        pytest.param(
+            DictConfig(ref_type=Plugin, content=ConcretePlugin),
+            Optional[Plugin],
+            id="Plugin",
+        ),
+        # Non optional DictConfig
+        pytest.param(
+            DictConfig(ref_type=Plugin, content=ConcretePlugin, is_optional=False),
+            Plugin,
+            id="Plugin",
+        ),
+        # ListConfig
+        pytest.param(ListConfig([]), Optional[List[Any]], id="ListConfig[Any]"),
+        pytest.param(
+            ListConfig([], element_type=int), Optional[List[int]], id="ListConfig[int]",
+        ),
+    ],
+)
+def test_get_ref_type(obj: Any, expected: Any) -> None:
+    assert _utils.get_ref_type(obj) == expected

pip install -e .[dev]
parse_log_pytest
pytest
pytest pytest-mock
3.7
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
attrs @ file:///croot/attrs_1668696182826/work
certifi @ file:///croot/certifi_1671487769961/work/certifi
flit_core @ file:///opt/conda/conda-bld/flit-core_1644941570762/work/source/flit_core
importlib-metadata @ file:///tmp/build/80754af9/importlib-metadata_1648562407465/work
iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
-e git+https://github.com/omry/omegaconf.git@37330820c65e3ae77b17e14d03814714af5315f9#egg=omegaconf
packaging @ file:///croot/packaging_1671697413597/work
pluggy @ file:///tmp/build/80754af9/pluggy_1648042572264/work
py @ file:///opt/conda/conda-bld/py_1644396412707/work
pytest==7.1.2
pytest-mock==3.11.1
PyYAML==6.0.1
tomli @ file:///opt/conda/conda-bld/tomli_1657175507142/work
typing_extensions @ file:///croot/typing_extensions_1669924550328/work
zipp @ file:///croot/zipp_1672387121353/work

name: omegaconf
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - attrs=22.1.0=py37h06a4308_0
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2022.12.7=py37h06a4308_0
  - flit-core=3.6.0=pyhd3eb1b0_0
  - importlib-metadata=4.11.3=py37h06a4308_0
  - importlib_metadata=4.11.3=hd3eb1b0_0
  - iniconfig=1.1.1=pyhd3eb1b0_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - packaging=22.0=py37h06a4308_0
  - pip=22.3.1=py37h06a4308_0
  - pluggy=1.0.0=py37h06a4308_1
  - py=1.11.0=pyhd3eb1b0_0
  - pytest=7.1.2=py37h06a4308_0
  - python=3.7.16=h7a1cb2a_0
  - readline=8.2=h5eee18b_0
  - setuptools=65.6.3=py37h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tomli=2.0.1=py37h06a4308_0
  - typing_extensions=4.4.0=py37h06a4308_0
  - wheel=0.38.4=py37h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - zipp=3.11.0=py37h06a4308_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - omegaconf==2.0.0rc25
      - pytest-mock==3.11.1
      - pyyaml==6.0.1
prefix: /opt/conda/envs/omegaconf

tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_on_non_structured_config_class[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_on_non_structured_config_class[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_on_non_structured_nested_config_class[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_on_non_structured_nested_config_class[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_assignment_of_subclass[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_assignment_of_subclass[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_assignment_of_non_subclass_1[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_assignment_of_non_subclass_1[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_of_non_subclass_1[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_of_non_subclass_1[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_error_new_attribute[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_error_new_attribute[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_error_override_bad_type[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_merge_error_override_bad_type[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_message[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestBasic::test_error_message[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::test_none_assignment[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::test_none_assignment[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_assignment_of_non_subclass_2[1-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_assignment_of_non_subclass_2[1-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_assignment_of_non_subclass_2[foo-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_assignment_of_non_subclass_2[foo-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_merge_of_non_subclass_2[1-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_merge_of_non_subclass_2[1-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_merge_of_non_subclass_2[foo-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestFailedAssignmentOrMerges::test_merge_of_non_subclass_2[foo-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::test_get_type[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::test_get_type[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_missing1[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_missing1[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_missing2[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_missing2[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_plugin_holder[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_plugin_holder[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_native_missing[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_basic.py::TestStructured::TestMissing::test_native_missing[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_nested_config_is_none[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_nested_config_is_none[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_nested_config[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_nested_config[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_value_without_a_default[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_value_without_a_default[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_union_errors[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_union_errors[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_config_with_list[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_config_with_list[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_assignment_to_nested_structured_config[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_assignment_to_nested_structured_config[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_assignment_to_structured_inside_dict_config[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_assignment_to_structured_inside_dict_config[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_config_with_dict[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_config_with_dict[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_structured_config_struct_behavior[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_structured_config_struct_behavior[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[BoolConfig-BoolConfigAssignments-init_dict0-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[BoolConfig-BoolConfigAssignments-init_dict0-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[IntegersConfig-IntegersConfigAssignments-init_dict1-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[IntegersConfig-IntegersConfigAssignments-init_dict1-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[FloatConfig-FloatConfigAssignments-init_dict2-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[FloatConfig-FloatConfigAssignments-init_dict2-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[StringConfig-StringConfigAssignments-init_dict3-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[StringConfig-StringConfigAssignments-init_dict3-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[EnumConfig-EnumConfigAssignments-init_dict4-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[EnumConfig-EnumConfigAssignments-init_dict4-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[BoolConfig-BoolConfigAssignments-init_dict5-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[BoolConfig-BoolConfigAssignments-init_dict5-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[IntegersConfig-IntegersConfigAssignments-init_dict6-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[IntegersConfig-IntegersConfigAssignments-init_dict6-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[FloatConfig-FloatConfigAssignments-init_dict7-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[FloatConfig-FloatConfigAssignments-init_dict7-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[StringConfig-StringConfigAssignments-init_dict8-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[StringConfig-StringConfigAssignments-init_dict8-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[EnumConfig-EnumConfigAssignments-init_dict9-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[EnumConfig-EnumConfigAssignments-init_dict9-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[AnyTypeConfig-AnyTypeConfigAssignments-init_dict10-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_field_with_default_value[AnyTypeConfig-AnyTypeConfigAssignments-init_dict10-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[None-expected_init0-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[None-expected_init0-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[input_init1-expected_init1-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[input_init1-expected_init1-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[None-expected_init2-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[None-expected_init2-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[input_init3-expected_init3-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_untyped[input_init3-expected_init3-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_interpolation[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_interpolation[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[BoolOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[BoolOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[IntegerOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[IntegerOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[FloatOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[FloatOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[StringOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[StringOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[EnumOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[EnumOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[StructuredOptional-tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_optional[StructuredOptional-tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_list[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_list[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_type1[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_type1[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_type2[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_type2[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_with_subclass[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_with_subclass[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_merge_with_subclass_into_missing[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_merge_with_subclass_into_missing[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_with_nons_subclass[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_merged_with_nons_subclass[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict_key_error[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict_key_error[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict_value_error[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_dict_value_error[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_list_value_error[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_typed_list_value_error[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_list_examples[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_list_examples[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_dict_examples[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_dict_examples[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_enum_key[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_enum_key[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_dict_of_objects[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_dict_of_objects[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_list_of_objects[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_list_of_objects[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_api[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_api[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_to_class[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_to_class[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_to_object[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestConfigs::test_promote_to_object[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::test_attr_frozen tests/structured_conf/test_structured_config.py::test_dataclass_frozen tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str_as_sub_node[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str_as_sub_node[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_color2str[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_color2str[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_color2color[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_color2color[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2user[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2user[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str_with_field[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2str_with_field[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2int_with_field_of_different_type[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::test_str2int_with_field_of_different_type[tests.structured_conf.data.attr_classes] tests/structured_conf/test_structured_config.py::TestDictSubclass::TestErrors::test_usr2str[tests.structured_conf.data.dataclasses] tests/structured_conf/test_structured_config.py::TestDictSubclass::TestErrors::test_usr2str[tests.structured_conf.data.attr_classes] tests/test_base_config.py::test_set_value[input_0-foo-10-expected0] tests/test_base_config.py::test_set_value[input_1-foo-value1-expected1] tests/test_base_config.py::test_set_value[input_2-foo-value2-expected2] tests/test_base_config.py::test_set_value[input_3-foo-value3-expected3] tests/test_base_config.py::test_set_value[input_4-0-10-expected4] tests/test_base_config.py::test_set_value[input_5-1-10-expected5] tests/test_base_config.py::test_set_value[input_6-1-value6-expected6] tests/test_base_config.py::test_set_value[input_7-1-value7-expected7] tests/test_base_config.py::test_set_value[input_8-1-value8-expected8] tests/test_base_config.py::test_set_value_validation_fail[input_0-foo-str] tests/test_base_config.py::test_set_value_validation_fail[input_1-1-str] tests/test_base_config.py::test_replace_value_node_type_with_another[input_0-foo-value0] tests/test_base_config.py::test_replace_value_node_type_with_another[input_1-1-value1] tests/test_base_config.py::test_to_container_returns_primitives[input_0] tests/test_base_config.py::test_to_container_returns_primitives[input_1] tests/test_base_config.py::test_to_container_returns_primitives[input_2] tests/test_base_config.py::test_to_container_returns_primitives[input_3] tests/test_base_config.py::test_to_container_returns_primitives[input_4] tests/test_base_config.py::test_empty[input_0-True] tests/test_base_config.py::test_empty[input_1-True] tests/test_base_config.py::test_empty[input_2-False] tests/test_base_config.py::test_empty[input_3-False] tests/test_base_config.py::test_str[input_0-[]-str] tests/test_base_config.py::test_str[input_0-[]-repr] tests/test_base_config.py::test_str[input_1-{}-str] tests/test_base_config.py::test_str[input_1-{}-repr] tests/test_base_config.py::test_str[input_2-[1, tests/test_base_config.py::test_str[input_3-[1, tests/test_base_config.py::test_str[input_4-[1, tests/test_base_config.py::test_str[input_5-{'b': tests/test_base_config.py::test_str[input_6-{'b': tests/test_base_config.py::test_str[StructuredWithMissing-{'num': tests/test_base_config.py::test_flag_dict[readonly] tests/test_base_config.py::test_flag_dict[struct] tests/test_base_config.py::test_freeze_nested_dict[readonly] tests/test_base_config.py::test_freeze_nested_dict[struct] tests/test_base_config.py::TestDeepCopy::test_deepcopy[src0] tests/test_base_config.py::TestDeepCopy::test_deepcopy[src1] tests/test_base_config.py::TestDeepCopy::test_deepcopy[src2] tests/test_base_config.py::TestDeepCopy::test_deepcopy[src3] tests/test_base_config.py::TestDeepCopy::test_deepcopy[StructuredWithMissing] tests/test_base_config.py::TestDeepCopy::test_deepcopy_readonly[src0] tests/test_base_config.py::TestDeepCopy::test_deepcopy_readonly[src1] tests/test_base_config.py::TestDeepCopy::test_deepcopy_readonly[src2] tests/test_base_config.py::TestDeepCopy::test_deepcopy_readonly[src3] tests/test_base_config.py::TestDeepCopy::test_deepcopy_readonly[StructuredWithMissing] tests/test_base_config.py::TestDeepCopy::test_deepcopy_struct[src0] tests/test_base_config.py::TestDeepCopy::test_deepcopy_struct[src1] tests/test_base_config.py::TestDeepCopy::test_deepcopy_struct[src2] tests/test_base_config.py::TestDeepCopy::test_deepcopy_struct[src3] tests/test_base_config.py::TestDeepCopy::test_deepcopy_struct[StructuredWithMissing] tests/test_base_config.py::test_deepcopy_after_del tests/test_base_config.py::test_deepcopy_after_pop tests/test_base_config.py::test_deepcopy_with_interpolation tests/test_base_config.py::test_deepcopy_and_merge_and_flags tests/test_base_config.py::test_deepcopy_preserves_container_type[cfg0] tests/test_base_config.py::test_deepcopy_preserves_container_type[cfg1] tests/test_base_config.py::test_flag_override[struct_setiitem] tests/test_base_config.py::test_flag_override[struct_setattr] tests/test_base_config.py::test_flag_override[readonly] tests/test_base_config.py::test_read_write_override[src0-<lambda>-expectation0] tests/test_base_config.py::test_read_write_override[src1-<lambda>-expectation1] tests/test_base_config.py::test_tokenize_with_escapes[dog,cat-tokenized0] tests/test_base_config.py::test_tokenize_with_escapes[dog\\,cat\\ tests/test_base_config.py::test_tokenize_with_escapes[dog,\\ tests/test_base_config.py::test_tokenize_with_escapes[\\ tests/test_base_config.py::test_tokenize_with_escapes[dog, tests/test_base_config.py::test_tokenize_with_escapes[whitespace\\ tests/test_base_config.py::test_tokenize_with_escapes[None-tokenized8] tests/test_base_config.py::test_tokenize_with_escapes[-tokenized9] tests/test_base_config.py::test_tokenize_with_escapes[no tests/test_base_config.py::test_struct_override[src0-<lambda>-expectation0] tests/test_base_config.py::test_open_dict_restore[struct-open_dict] tests/test_base_config.py::test_open_dict_restore[readonly-read_write] tests/test_base_config.py::TestCopy::test_copy[src0-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src0-<lambda>1] tests/test_base_config.py::TestCopy::test_copy[src1-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src1-<lambda>1] tests/test_base_config.py::TestCopy::test_copy[src2-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src2-<lambda>1] tests/test_base_config.py::TestCopy::test_copy[src3-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src3-<lambda>1] tests/test_base_config.py::TestCopy::test_copy[src4-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src4-<lambda>1] tests/test_base_config.py::TestCopy::test_copy[src5-<lambda>0] tests/test_base_config.py::TestCopy::test_copy[src5-<lambda>1] tests/test_base_config.py::TestCopy::test_copy_with_interpolation[src0-2-0-<lambda>0] tests/test_base_config.py::TestCopy::test_copy_with_interpolation[src0-2-0-<lambda>1] tests/test_base_config.py::TestCopy::test_copy_with_interpolation[src1-b-a-<lambda>0] tests/test_base_config.py::TestCopy::test_copy_with_interpolation[src1-b-a-<lambda>1] tests/test_base_config.py::TestCopy::test_list_copy_is_shallow[<lambda>0] tests/test_base_config.py::TestCopy::test_list_copy_is_shallow[<lambda>1] tests/test_base_config.py::test_not_implemented tests/test_base_config.py::test_resolve_str_interpolation[a-a] tests/test_base_config.py::test_resolve_str_interpolation[${foo}-10] tests/test_base_config.py::test_resolve_str_interpolation[${bar}-10] tests/test_base_config.py::test_resolve_str_interpolation[foo_${foo}-foo_10] tests/test_base_config.py::test_resolve_str_interpolation[foo_${bar}-foo_10] tests/test_base_config.py::test_omegaconf_create tests/test_base_config.py::test_assign[parent0-0-value0-expected0] tests/test_base_config.py::test_assign[parent1-0-value1-expected1] tests/test_base_config.py::test_assign[parent2-0-value2-expected2] tests/test_base_config.py::test_assign[parent3-foo-value3-expected3] tests/test_base_config.py::test_assign[parent4-foo-value4-expected4] tests/test_base_config.py::test_assign[parent5-foo-value5-expected5] tests/test_base_config.py::test_get_node[cfg0-foo-bar] tests/test_base_config.py::test_get_node[cfg1-foo-None] tests/test_base_config.py::test_get_node[cfg2-foo-???] tests/test_base_config.py::test_get_node[cfg3-1-20] tests/test_base_config.py::test_get_node[cfg4-1-None] tests/test_base_config.py::test_get_node[cfg5-1-???] tests/test_basic_ops_dict.py::test_setattr_deep_value tests/test_basic_ops_dict.py::test_setattr_deep_from_empty tests/test_basic_ops_dict.py::test_setattr_deep_map tests/test_basic_ops_dict.py::test_getattr tests/test_basic_ops_dict.py::test_getattr_dict tests/test_basic_ops_dict.py::test_mandatory_value tests/test_basic_ops_dict.py::test_nested_dict_mandatory_value tests/test_basic_ops_dict.py::test_mandatory_with_default tests/test_basic_ops_dict.py::test_subscript_get tests/test_basic_ops_dict.py::test_subscript_set tests/test_basic_ops_dict.py::test_pretty_dict tests/test_basic_ops_dict.py::test_pretty_sort_keys tests/test_basic_ops_dict.py::test_pretty_dict_unicode tests/test_basic_ops_dict.py::test_default_value tests/test_basic_ops_dict.py::test_get_default_value tests/test_basic_ops_dict.py::test_scientific_notation_float tests/test_basic_ops_dict.py::test_dict_get_with_default[d0--missing] tests/test_basic_ops_dict.py::test_dict_get_with_default[d1-hello-missing] tests/test_basic_ops_dict.py::test_dict_get_with_default[d2--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d3--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d4--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d5--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d6--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d7--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d8--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d9--hello] tests/test_basic_ops_dict.py::test_dict_get_with_default[d10--hello] tests/test_basic_ops_dict.py::test_map_expansion tests/test_basic_ops_dict.py::test_items tests/test_basic_ops_dict.py::test_items2 tests/test_basic_ops_dict.py::test_items_with_interpolation tests/test_basic_ops_dict.py::test_dict_keys tests/test_basic_ops_dict.py::test_pickle_get_root tests/test_basic_ops_dict.py::test_iterate_dictionary tests/test_basic_ops_dict.py::test_iterate_dict_with_interpolation tests/test_basic_ops_dict.py::test_dict_pop[no_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[no_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[no_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[none_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[none_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[none_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[with_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[with_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[with_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[interpolation-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[interpolation-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[interpolation-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[interpolation_with_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[interpolation_with_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[interpolation_with_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_no_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_no_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_no_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_none_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_none_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_none_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_default-struct_unspecified] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_default-struct_False] tests/test_basic_ops_dict.py::test_dict_pop[enum_key_with_default-struct_True] tests/test_basic_ops_dict.py::test_dict_pop_error[cfg0-not_found-expectation0] tests/test_basic_ops_dict.py::test_dict_pop_error[cfg1-a-expectation1] tests/test_basic_ops_dict.py::test_dict_pop_error[cfg2-a-expectation2] tests/test_basic_ops_dict.py::test_dict_pop_error[cfg3-Enum1.BAR-expectation3] tests/test_basic_ops_dict.py::test_in_dict[conf0-a-True] tests/test_basic_ops_dict.py::test_in_dict[conf1-b-True] tests/test_basic_ops_dict.py::test_in_dict[conf2-c-False] tests/test_basic_ops_dict.py::test_in_dict[conf3-b-True] tests/test_basic_ops_dict.py::test_in_dict[conf4-b-False] tests/test_basic_ops_dict.py::test_in_dict[conf5-c-False] tests/test_basic_ops_dict.py::test_in_dict[conf6-b-False] tests/test_basic_ops_dict.py::test_in_dict[conf7-a-True] tests/test_basic_ops_dict.py::test_in_dict[conf8-b-True] tests/test_basic_ops_dict.py::test_in_dict[conf9-b-True] tests/test_basic_ops_dict.py::test_in_dict[conf10-Enum1.FOO-True] tests/test_basic_ops_dict.py::test_get_root tests/test_basic_ops_dict.py::test_get_root_of_merged tests/test_basic_ops_dict.py::test_dict_config tests/test_basic_ops_dict.py::test_dict_delitem tests/test_basic_ops_dict.py::test_dict_len[d0-0] tests/test_basic_ops_dict.py::test_dict_len[d1-2] tests/test_basic_ops_dict.py::test_dict_assign_illegal_value tests/test_basic_ops_dict.py::test_dict_assign_illegal_value_nested tests/test_basic_ops_dict.py::test_assign_dict_in_dict tests/test_basic_ops_dict.py::test_to_container[src0] tests/test_basic_ops_dict.py::test_to_container[src1] tests/test_basic_ops_dict.py::test_to_container[src2] tests/test_basic_ops_dict.py::test_pretty_without_resolve tests/test_basic_ops_dict.py::test_pretty_with_resolve tests/test_basic_ops_dict.py::test_instantiate_config_fails tests/test_basic_ops_dict.py::test_dir[cfg0-None-expected0] tests/test_basic_ops_dict.py::test_dir[cfg1-a-expected1] tests/test_basic_ops_dict.py::test_dir[StructuredWithMissing-dict-expected2] tests/test_basic_ops_dict.py::test_hash tests/test_basic_ops_dict.py::test_get_with_default_from_struct_not_throwing[default] tests/test_basic_ops_dict.py::test_get_with_default_from_struct_not_throwing[0] tests/test_basic_ops_dict.py::test_get_with_default_from_struct_not_throwing[None] tests/test_basic_ops_dict.py::test_members tests/test_basic_ops_dict.py::test_masked_copy[in_cfg0-mask_keys0-expected0] tests/test_basic_ops_dict.py::test_masked_copy[in_cfg1-a-expected1] tests/test_basic_ops_dict.py::test_masked_copy[in_cfg2-mask_keys2-expected2] tests/test_basic_ops_dict.py::test_masked_copy[in_cfg3-b-expected3] tests/test_basic_ops_dict.py::test_masked_copy[in_cfg4-mask_keys4-expected4] tests/test_basic_ops_dict.py::test_masked_copy_is_deep tests/test_basic_ops_dict.py::test_creation_with_invalid_key tests/test_basic_ops_dict.py::test_set_with_invalid_key tests/test_basic_ops_dict.py::test_get_with_invalid_key tests/test_basic_ops_dict.py::test_hasattr tests/test_basic_ops_dict.py::test_struct_mode_missing_key_getitem tests/test_basic_ops_dict.py::test_struct_mode_missing_key_setitem tests/test_basic_ops_dict.py::test_get_type tests/test_basic_ops_dict.py::test_get_ref_type[cfg0-expected_ref_type0] tests/test_basic_ops_dict.py::test_get_ref_type[cfg1-Plugin] tests/test_basic_ops_dict.py::test_get_ref_type_with_conflict tests/test_basic_ops_dict.py::test_is_missing tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[None-None] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[None-ref_type1] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign1-None] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign1-ref_type1] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign2-None] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign2-ref_type1] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign3-None] tests/test_basic_ops_dict.py::test_assign_to_reftype_none_or_any[assign3-ref_type1] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values0-None-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values1-Plugin-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values2-assign2-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values3-ConcretePlugin-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values4-assign4-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[Plugin-values5-10-<lambda>] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[ConcretePlugin-values6-None-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[ConcretePlugin-values7-Plugin-<lambda>] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[ConcretePlugin-values8-assign8-<lambda>] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[ConcretePlugin-values9-ConcretePlugin-does_not_raise] tests/test_basic_ops_dict.py::test_assign_to_reftype_plugin[ConcretePlugin-values10-assign10-does_not_raise] tests/test_basic_ops_list.py::test_list_value tests/test_basic_ops_list.py::test_list_of_dicts tests/test_basic_ops_list.py::test_pretty_list tests/test_basic_ops_list.py::test_pretty_list_unicode tests/test_basic_ops_list.py::test_list_get_with_default tests/test_basic_ops_list.py::test_iterate_list[simple] tests/test_basic_ops_list.py::test_iterate_list[interpolation] tests/test_basic_ops_list.py::test_iterate_list[str_interpolation] tests/test_basic_ops_list.py::test_iterate_list_with_missing_interpolation tests/test_basic_ops_list.py::test_iterate_list_with_missing tests/test_basic_ops_list.py::test_items_with_interpolation tests/test_basic_ops_list.py::test_list_pop tests/test_basic_ops_list.py::test_list_pop_on_unexpected_exception_not_modifying tests/test_basic_ops_list.py::test_in_list tests/test_basic_ops_list.py::test_list_config_with_list tests/test_basic_ops_list.py::test_list_config_with_tuple tests/test_basic_ops_list.py::test_items_on_list tests/test_basic_ops_list.py::test_list_enumerate tests/test_basic_ops_list.py::test_list_delitem tests/test_basic_ops_list.py::test_list_len[lst0-2] tests/test_basic_ops_list.py::test_list_len[lst1-0] tests/test_basic_ops_list.py::test_list_len[lst2-0] tests/test_basic_ops_list.py::test_nested_list_assign_illegal_value tests/test_basic_ops_list.py::test_list_append tests/test_basic_ops_list.py::test_pretty_without_resolve tests/test_basic_ops_list.py::test_pretty_with_resolve tests/test_basic_ops_list.py::test_list_index[index0-expected0] tests/test_basic_ops_list.py::test_list_index[index1-expected1] tests/test_basic_ops_list.py::test_list_index[-1-13] tests/test_basic_ops_list.py::test_list_dir[cfg0-expected0] tests/test_basic_ops_list.py::test_list_dir[cfg1-expected1] tests/test_basic_ops_list.py::test_list_dir[cfg2-expected2] tests/test_basic_ops_list.py::test_insert[input_0-1-100-expected0-AnyNode-None] tests/test_basic_ops_list.py::test_insert[input_1-1-value1-expected1-IntegerNode-None] tests/test_basic_ops_list.py::test_insert[input_2-1-foo-expected2-AnyNode-None] tests/test_basic_ops_list.py::test_insert[input_3-1-value3-expected3-StringNode-None] tests/test_basic_ops_list.py::test_insert[input_4-0-foo-None-None-ValidationError] tests/test_basic_ops_list.py::test_insert_special_list[lst0-0-10-expectation0] tests/test_basic_ops_list.py::test_insert_special_list[lst1-0-10-expectation1] tests/test_basic_ops_list.py::test_extend[src0-append0-result0] tests/test_basic_ops_list.py::test_extend[src1-append1-result1] tests/test_basic_ops_list.py::test_extend[src2-append2-result2] tests/test_basic_ops_list.py::test_remove[src0-10-result0-expectation0] tests/test_basic_ops_list.py::test_remove[src1-oops-None-expectation1] tests/test_basic_ops_list.py::test_remove[src2-remove2-result2-expectation2] tests/test_basic_ops_list.py::test_remove[src3-2-result3-expectation3] tests/test_basic_ops_list.py::test_clear[1-src0] tests/test_basic_ops_list.py::test_clear[1-src1] tests/test_basic_ops_list.py::test_clear[1-src2] tests/test_basic_ops_list.py::test_clear[2-src0] tests/test_basic_ops_list.py::test_clear[2-src1] tests/test_basic_ops_list.py::test_clear[2-src2] tests/test_basic_ops_list.py::test_index[src0-20--1-expectation0] tests/test_basic_ops_list.py::test_index[src1-10-0-expectation1] tests/test_basic_ops_list.py::test_index[src2-20-1-expectation2] tests/test_basic_ops_list.py::test_index_with_range tests/test_basic_ops_list.py::test_count[src0-10-0] tests/test_basic_ops_list.py::test_count[src1-10-1] tests/test_basic_ops_list.py::test_count[src2-10-2] tests/test_basic_ops_list.py::test_count[src3-None-0] tests/test_basic_ops_list.py::test_sort tests/test_basic_ops_list.py::test_insert_throws_not_changing_list tests/test_basic_ops_list.py::test_append_throws_not_changing_list tests/test_basic_ops_list.py::test_hash tests/test_basic_ops_list.py::TestListAdd::test_list_plus[in_list10-in_list20-in_expected0] tests/test_basic_ops_list.py::TestListAdd::test_list_plus[in_list11-in_list21-in_expected1] tests/test_basic_ops_list.py::TestListAdd::test_list_plus[in_list12-in_list22-in_expected2] tests/test_basic_ops_list.py::TestListAdd::test_list_plus_eq[in_list10-in_list20-in_expected0] tests/test_basic_ops_list.py::TestListAdd::test_list_plus_eq[in_list11-in_list21-in_expected1] tests/test_basic_ops_list.py::TestListAdd::test_list_plus_eq[in_list12-in_list22-in_expected2] tests/test_basic_ops_list.py::test_deep_add tests/test_basic_ops_list.py::test_set_with_invalid_key tests/test_basic_ops_list.py::test_getitem[lst0-0-1] tests/test_basic_ops_list.py::test_getitem[lst1-0-TypeError] tests/test_basic_ops_list.py::test_getitem[lst2-0-MissingMandatoryValue] tests/test_basic_ops_list.py::test_get[lst0-0-1] tests/test_basic_ops_list.py::test_get[lst1-foo-KeyValidationError] tests/test_basic_ops_list.py::test_get[lst2-0-TypeError] tests/test_basic_ops_list.py::test_get[lst3-0-MissingMandatoryValue] tests/test_basic_ops_list.py::test_getattr tests/test_create.py::test_create_value[None-None] tests/test_create.py::test_create_value[input_1-expected1] tests/test_create.py::test_create_value[hello-expected2] tests/test_create.py::test_create_value[hello: tests/test_create.py::test_create_value[input_4-expected4] tests/test_create.py::test_create_value[-expected5] tests/test_create.py::test_create_value[input_6-expected6] tests/test_create.py::test_create_value[input_7-expected7] tests/test_create.py::test_create_value[input_8-expected8] tests/test_create.py::test_create_value[input_9-expected9] tests/test_create.py::test_create_value[input_10-expected10] tests/test_create.py::test_create_value[input_11-expected11] tests/test_create.py::test_create_value[input_12-expected12] tests/test_create.py::test_create_value[input_13-expected13] tests/test_create.py::test_create_value[input_14-expected14] tests/test_create.py::test_create_value[input_15-expected15] tests/test_create.py::test_create_value[input_16-expected16] tests/test_create.py::test_create_value[input_17-expected17] tests/test_create.py::test_create_value[input_18-expected18] tests/test_create.py::test_create_from_cli tests/test_create.py::test_cli_passing tests/test_create.py::test_dotlist[input_0-expected0] tests/test_create.py::test_dotlist[input_1-expected1] tests/test_create.py::test_dotlist[input_2-expected2] tests/test_create.py::test_create_list_with_illegal_value_idx0 tests/test_create.py::test_create_list_with_illegal_value_idx1 tests/test_create.py::test_create_dict_with_illegal_value tests/test_create.py::test_create_nested_dict_with_illegal_value tests/test_create.py::test_create_from_oc tests/test_create.py::test_create_from_oc_with_flags tests/test_create.py::test_create_from_dictconfig_preserves_metadata tests/test_create.py::test_create_from_listconfig_preserves_metadata tests/test_create.py::test_create_node_parent_retained_on_create[node0] tests/test_create.py::test_create_node_parent_retained_on_create[node1] tests/test_errors.py::test_errors[structured:update_with_invalid_value] tests/test_errors.py::test_errors[structured:update:none_to_non_optional] tests/test_errors.py::test_errors[dict:update:object_of_illegal_type] tests/test_errors.py::test_errors[dict,readonly:pop] tests/test_errors.py::test_errors[dict:pop_invalid] tests/test_errors.py::test_errors[dict:pop_invalid_nested] tests/test_errors.py::test_errors[structured:access_invalid_attribute] tests/test_errors.py::test_errors[dict,struct:access_invalid_attribute] tests/test_errors.py::test_errors[dict,accessing_missing_interpolation] tests/test_errors.py::test_errors[dict,accessing_missing_str_interpolation] tests/test_errors.py::test_errors[dict,struct:set_invalid_attribute] tests/test_errors.py::test_errors[structured:setattr,invalid_type_assigned_to_structured] tests/test_errors.py::test_errors[dict,readonly:set_attribute] tests/test_errors.py::test_errors[dict,not_optional:set_none] tests/test_errors.py::test_errors[structured:setattr,invalid_type_assigned_to_field] tests/test_errors.py::test_errors[dict,struct:setitem_on_none_existing_key] tests/test_errors.py::test_errors[dict,struct:getitem_key_not_in_struct] tests/test_errors.py::test_errors[DictConfig[Color,str]:getitem_str_key] tests/test_errors.py::test_errors[DictConfig[str,str]:getitem_color_key] tests/test_errors.py::test_errors[dict,readonly:merge_with] tests/test_errors.py::test_errors[structured:merge,invalid_field_type] tests/test_errors.py::test_errors[structured:merge,adding_an_invalid_key] tests/test_errors.py::test_errors[structured:merge_invalid_dataclass] tests/test_errors.py::test_errors[dict:get_illegal_type] tests/test_errors.py::test_errors[dict:get_object_of_illegal_type] tests/test_errors.py::test_errors[dict_create_none_optional_with_none] tests/test_errors.py::test_errors[dict_create_from_illegal_type] tests/test_errors.py::test_errors[structured:create_from_unsupported_object] tests/test_errors.py::test_errors[structured:create_with_union_error] tests/test_errors.py::test_errors[dict:set_value:reftype_mismatch] tests/test_errors.py::test_errors[DictConfig[str,int]:assigned_str_value] tests/test_errors.py::test_errors[dict,readonly:del] tests/test_errors.py::test_errors[list:setattr0] tests/test_errors.py::test_errors[list:setattr1] tests/test_errors.py::test_errors[list:get_nox_ex:invalid_index_type] tests/test_errors.py::test_errors[list:get_node_ex:index_out_of_range] tests/test_errors.py::test_errors[list:get_node_none] tests/test_errors.py::test_errors[list:get_node_missing] tests/test_errors.py::test_errors[list:create_not_optional_with_none] tests/test_errors.py::test_errors[list:append_value_of_illegal_type] tests/test_errors.py::test_errors[list:readonly:pop] tests/test_errors.py::test_errors[list:pop_invalid_key] tests/test_errors.py::test_errors[list:pop_from_none] tests/test_errors.py::test_errors[list:pop_from_missing] tests/test_errors.py::test_errors[list:subscript_slice_with_missing] tests/test_errors.py::test_errors[list:subscript_index_with_missing] tests/test_errors.py::test_errors[list:subscript:index_out_of_range] tests/test_errors.py::test_errors[list:getitem,illegal_key_type0] tests/test_errors.py::test_errors[list:getitem,illegal_key_type1] tests/test_errors.py::test_errors[list:setitem,illegal_value_type] tests/test_errors.py::test_errors[list:setitem,illegal_key_type] tests/test_errors.py::test_errors[list,readonly:setitem] tests/test_errors.py::test_errors[list:create_not_optional:_set_value(None)] tests/test_errors.py::test_errors[list,int_elements:assigned_str_element0] tests/test_errors.py::test_errors[list,int_elements:assigned_str_element1] tests/test_errors.py::test_errors[list,not_optional:null_assignment] tests/test_errors.py::test_errors[list,readonly:index_not_found] tests/test_errors.py::test_errors[list,readonly:insert] tests/test_errors.py::test_errors[list:insert_into_none] tests/test_errors.py::test_errors[list:insert_into_missing] tests/test_errors.py::test_errors[list:get_from_none] tests/test_errors.py::test_errors[list:get_from_missing] tests/test_errors.py::test_errors[list:readonly:sort0] tests/test_errors.py::test_errors[list:sort_from_none] tests/test_errors.py::test_errors[list:sort_from_missing] tests/test_errors.py::test_errors[list:readonly:sort1] tests/test_errors.py::test_errors[list:iter_none] tests/test_errors.py::test_errors[list:iter_missing] tests/test_errors.py::test_errors[list,readonly:del] tests/test_get_full_key.py::test_get_full_key_from_config[cfg0--a-a] tests/test_get_full_key.py::test_get_full_key_from_config[cfg1--a-a] tests/test_get_full_key.py::test_get_full_key_from_config[cfg2--bad-bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg3---] tests/test_get_full_key.py::test_get_full_key_from_config[cfg4--bad-bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg5--2-[2]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg6--999-[999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg7---] tests/test_get_full_key.py::test_get_full_key_from_config[cfg8--999-[999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg9-b-c-b.c] tests/test_get_full_key.py::test_get_full_key_from_config[cfg10-b-bad-b.bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg11-a-1-a[1]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg12-a-999-a[999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg13-0-2-[0][2]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg14-0-999-[0][999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg15-2-a-[2].a] tests/test_get_full_key.py::test_get_full_key_from_config[cfg16-2-bad-[2].bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg17-b--b] tests/test_get_full_key.py::test_get_full_key_from_config[cfg18-b-bad-b.bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg19-a.b-c-a.b.c] tests/test_get_full_key.py::test_get_full_key_from_config[cfg20-a.b-bad-a.b.bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg21-a.b-0-a.b[0]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg22-a.b-999-a.b[999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg23-a.1-0-a[1][0]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg24-a.1-999-a[1][999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg25-a.0-b-a[0].b] tests/test_get_full_key.py::test_get_full_key_from_config[cfg26-a.0-bad-a[0].bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg27-0.a-b-[0].a.b] tests/test_get_full_key.py::test_get_full_key_from_config[cfg28-0.a-bad-[0].a.bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg29-0.a-0-[0].a[0]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg30-0.a-999-[0].a[999]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg31-0.0-a-[0][0].a] tests/test_get_full_key.py::test_get_full_key_from_config[cfg32-0.0-bad-[0][0].bad] tests/test_get_full_key.py::test_get_full_key_from_config[cfg33-0.0-0-[0][0][0]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg34-0.0.a.a-0-[0][0].a.a[0]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg35-b-c-b.c] tests/test_get_full_key.py::test_get_full_key_from_config[cfg36--foo-foo] tests/test_get_full_key.py::test_get_full_key_from_config[cfg37-foo-bar-foo.bar] tests/test_get_full_key.py::test_get_full_key_from_config[get_full_key_with_enum_key] tests/test_get_full_key.py::test_get_full_key_from_config[get_full_key_with_nested_enum_key] tests/test_get_full_key.py::test_get_full_key_from_config[cfg40--key40-[0:1]] tests/test_get_full_key.py::test_get_full_key_from_config[cfg41--key41-[0:1:2]] tests/test_get_full_key.py::test_value_node_get_full_key tests/test_omegaconf.py::test_is_missing[cfg0-foo-False-expectation0] tests/test_omegaconf.py::test_is_missing[cfg1-foo-False-expectation1] tests/test_omegaconf.py::test_is_missing[cfg2-foo-True-expectation2] tests/test_omegaconf.py::test_is_missing[cfg3-foo-True-expectation3] tests/test_omegaconf.py::test_is_missing[cfg4-foo-False-expectation4] tests/test_omegaconf.py::test_is_missing[cfg5-foo-True-expectation5] tests/test_omegaconf.py::test_is_missing[cfg6-inter-True-expectation6] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-num-True-expectation7] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-opt_num-True-expectation8] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-dict-True-expectation9] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-opt_dict-True-expectation10] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-list-True-expectation11] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-opt_list-True-expectation12] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-user-True-expectation13] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-opt_user-True-expectation14] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-inter_user-True-expectation15] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-inter_opt_user-True-expectation16] tests/test_omegaconf.py::test_is_missing[StructuredWithMissing-inter_num-True-expectation17] tests/test_omegaconf.py::test_is_missing_resets tests/test_omegaconf.py::test_is_config[None-False] tests/test_omegaconf.py::test_is_config[cfg1-False] tests/test_omegaconf.py::test_is_config[cfg2-False] tests/test_omegaconf.py::test_is_config[aa-False] tests/test_omegaconf.py::test_is_config[10-False] tests/test_omegaconf.py::test_is_config[True-False] tests/test_omegaconf.py::test_is_config[bool-False] tests/test_omegaconf.py::test_is_config[cfg7-False] tests/test_omegaconf.py::test_is_config[ConcretePlugin-False] tests/test_omegaconf.py::test_is_config[cfg9-False] tests/test_omegaconf.py::test_is_config[cfg10-True] tests/test_omegaconf.py::test_is_config[cfg11-True] tests/test_omegaconf.py::test_is_config[cfg12-True] tests/test_omegaconf.py::test_is_config[cfg13-True] tests/test_omegaconf.py::test_is_list[None-False] tests/test_omegaconf.py::test_is_list[cfg1-False] tests/test_omegaconf.py::test_is_list[cfg2-False] tests/test_omegaconf.py::test_is_list[aa-False] tests/test_omegaconf.py::test_is_list[10-False] tests/test_omegaconf.py::test_is_list[True-False] tests/test_omegaconf.py::test_is_list[bool-False] tests/test_omegaconf.py::test_is_list[cfg7-False] tests/test_omegaconf.py::test_is_list[ConcretePlugin-False] tests/test_omegaconf.py::test_is_list[cfg9-False] tests/test_omegaconf.py::test_is_list[cfg10-False] tests/test_omegaconf.py::test_is_list[cfg11-True] tests/test_omegaconf.py::test_is_list[cfg12-False] tests/test_omegaconf.py::test_is_list[cfg13-False] tests/test_omegaconf.py::test_is_dict[None-False] tests/test_omegaconf.py::test_is_dict[cfg1-False] tests/test_omegaconf.py::test_is_dict[cfg2-False] tests/test_omegaconf.py::test_is_dict[aa-False] tests/test_omegaconf.py::test_is_dict[10-False] tests/test_omegaconf.py::test_is_dict[True-False] tests/test_omegaconf.py::test_is_dict[bool-False] tests/test_omegaconf.py::test_is_dict[cfg7-False] tests/test_omegaconf.py::test_is_dict[ConcretePlugin-False] tests/test_omegaconf.py::test_is_dict[cfg9-False] tests/test_omegaconf.py::test_is_dict[cfg10-True] tests/test_omegaconf.py::test_is_dict[cfg11-False] tests/test_omegaconf.py::test_is_dict[cfg12-True] tests/test_omegaconf.py::test_is_dict[cfg13-True] tests/test_omegaconf.py::test_is_optional[<lambda>0-True] tests/test_omegaconf.py::test_is_optional[<lambda>0-False] tests/test_omegaconf.py::test_is_optional[<lambda>1-True] tests/test_omegaconf.py::test_is_optional[<lambda>1-False] tests/test_omegaconf.py::test_is_optional[<lambda>2-True] tests/test_omegaconf.py::test_is_optional[<lambda>2-False] tests/test_omegaconf.py::test_is_optional[<lambda>3-True] tests/test_omegaconf.py::test_is_optional[<lambda>3-False] tests/test_omegaconf.py::test_is_optional[<lambda>4-True] tests/test_omegaconf.py::test_is_optional[<lambda>4-False] tests/test_omegaconf.py::test_is_optional[<lambda>5-True] tests/test_omegaconf.py::test_is_optional[<lambda>5-False] tests/test_omegaconf.py::test_is_optional[<lambda>6-True] tests/test_omegaconf.py::test_is_optional[<lambda>6-False] tests/test_omegaconf.py::test_is_optional[<lambda>7-True] tests/test_omegaconf.py::test_is_optional[<lambda>7-False] tests/test_omegaconf.py::test_is_none[<lambda>0-True] tests/test_omegaconf.py::test_is_none[<lambda>0-False] tests/test_omegaconf.py::test_is_none[<lambda>1-True] tests/test_omegaconf.py::test_is_none[<lambda>1-False] tests/test_omegaconf.py::test_is_none[<lambda>2-True] tests/test_omegaconf.py::test_is_none[<lambda>2-False] tests/test_omegaconf.py::test_is_none[<lambda>3-True] tests/test_omegaconf.py::test_is_none[<lambda>3-False] tests/test_omegaconf.py::test_is_none[<lambda>4-True] tests/test_omegaconf.py::test_is_none[<lambda>4-False] tests/test_omegaconf.py::test_is_none[<lambda>5-True] tests/test_omegaconf.py::test_is_none[<lambda>5-False] tests/test_omegaconf.py::test_is_none[<lambda>6-True] tests/test_omegaconf.py::test_is_none[<lambda>6-False] tests/test_omegaconf.py::test_is_none[<lambda>7-True] tests/test_omegaconf.py::test_is_none[<lambda>7-False] tests/test_omegaconf.py::test_is_interpolation[StringNode] tests/test_omegaconf.py::test_is_interpolation[IntegerNode] tests/test_omegaconf.py::test_is_interpolation[FloatNode] tests/test_omegaconf.py::test_is_interpolation[BooleanNode] tests/test_omegaconf.py::test_is_interpolation[EnumNode] tests/test_omegaconf.py::test_is_interpolation[ListConfig] tests/test_omegaconf.py::test_is_interpolation[DictConfig] tests/test_omegaconf.py::test_is_interpolation[ConcretePlugin] tests/test_omegaconf.py::test_get_type[cfg0-int] tests/test_omegaconf.py::test_get_type[cfg1-float] tests/test_omegaconf.py::test_get_type[cfg2-bool] tests/test_omegaconf.py::test_get_type[cfg3-str] tests/test_omegaconf.py::test_get_type[cfg4-NoneType] tests/test_omegaconf.py::test_get_type[cfg5-ConcretePlugin] tests/test_omegaconf.py::test_get_type[cfg6-ConcretePlugin] tests/test_omegaconf.py::test_get_type[cfg7-dict] tests/test_omegaconf.py::test_get_type[cfg8-dict] tests/test_omegaconf.py::test_get_type[cfg9-list] tests/test_omegaconf.py::test_get_type[cfg10-list] tests/test_omegaconf.py::test_get_type_on_raw[10-int] tests/test_omegaconf.py::test_get_type_on_raw[10.0-float] tests/test_omegaconf.py::test_get_type_on_raw[True-bool] tests/test_omegaconf.py::test_get_type_on_raw[foo-str] tests/test_omegaconf.py::test_get_type_on_raw[obj4-dict] tests/test_omegaconf.py::test_get_type_on_raw[obj5-list] tests/test_omegaconf.py::test_get_type_on_raw[IllegalType-IllegalType] tests/test_omegaconf.py::test_get_type_on_raw[obj7-IllegalType] tests/test_omegaconf.py::test_is_issubclass tests/test_utils.py::test_node_wrap[any0] tests/test_utils.py::test_node_wrap[any1] tests/test_utils.py::test_node_wrap[any2] tests/test_utils.py::test_node_wrap[any3] tests/test_utils.py::test_node_wrap[any4] tests/test_utils.py::test_node_wrap[any_as_dict] tests/test_utils.py::test_node_wrap[any_as_list] tests/test_utils.py::test_node_wrap[int0] tests/test_utils.py::test_node_wrap[int1] tests/test_utils.py::test_node_wrap[int2] tests/test_utils.py::test_node_wrap[int3] tests/test_utils.py::test_node_wrap[int4] tests/test_utils.py::test_node_wrap[float0] tests/test_utils.py::test_node_wrap[float1] tests/test_utils.py::test_node_wrap[float2] tests/test_utils.py::test_node_wrap[float3] tests/test_utils.py::test_node_wrap[float4] tests/test_utils.py::test_node_wrap[bool0] tests/test_utils.py::test_node_wrap[bool1] tests/test_utils.py::test_node_wrap[bool2] tests/test_utils.py::test_node_wrap[bool3] tests/test_utils.py::test_node_wrap[bool4] tests/test_utils.py::test_node_wrap[bool5] tests/test_utils.py::test_node_wrap[bool6] tests/test_utils.py::test_node_wrap[bool7] tests/test_utils.py::test_node_wrap[bool8] tests/test_utils.py::test_node_wrap[bool9] tests/test_utils.py::test_node_wrap[str0] tests/test_utils.py::test_node_wrap[str1] tests/test_utils.py::test_node_wrap[str2] tests/test_utils.py::test_node_wrap[str3] tests/test_utils.py::test_node_wrap[str4] tests/test_utils.py::test_node_wrap[Color0] tests/test_utils.py::test_node_wrap[Color1] tests/test_utils.py::test_node_wrap[Color2] tests/test_utils.py::test_node_wrap[Color3] tests/test_utils.py::test_node_wrap[Color4] tests/test_utils.py::test_node_wrap[Color5] tests/test_utils.py::test_node_wrap[Color6] tests/test_utils.py::test_node_wrap[bad_type] tests/test_utils.py::test_node_wrap[DictConfig] tests/test_utils.py::test_node_wrap[DictConfig[Plugin]] tests/test_utils.py::test_node_wrap[ListConfig] tests/test_utils.py::test_valid_value_annotation_type[int-True] tests/test_utils.py::test_valid_value_annotation_type[float-True] tests/test_utils.py::test_valid_value_annotation_type[bool-True] tests/test_utils.py::test_valid_value_annotation_type[str-True] tests/test_utils.py::test_valid_value_annotation_type[type_4-True] tests/test_utils.py::test_valid_value_annotation_type[_TestEnum-True] tests/test_utils.py::test_valid_value_annotation_type[_TestUserClass-False] tests/test_utils.py::test_valid_value_annotation_type[_TestAttrsClass-True] tests/test_utils.py::test_valid_value_annotation_type[_TestDataclass-True] tests/test_utils.py::test_get_structured_config_data[_TestDataclass-expectation0] tests/test_utils.py::test_get_structured_config_data[test_cls_or_obj1-expectation1] tests/test_utils.py::test_get_structured_config_data[_TestAttrsClass-expectation2] tests/test_utils.py::test_get_structured_config_data[test_cls_or_obj3-expectation3] tests/test_utils.py::test_get_structured_config_data[invalid-expectation4] tests/test_utils.py::test_is_dataclass tests/test_utils.py::test_is_attr_class tests/test_utils.py::test_is_structured_config_frozen_with_invalid_obj tests/test_utils.py::test_value_kind[foo-ValueKind.VALUE] tests/test_utils.py::test_value_kind[1-ValueKind.VALUE] tests/test_utils.py::test_value_kind[1.0-ValueKind.VALUE] tests/test_utils.py::test_value_kind[True-ValueKind.VALUE] tests/test_utils.py::test_value_kind[False-ValueKind.VALUE] tests/test_utils.py::test_value_kind[Color.GREEN-ValueKind.VALUE] tests/test_utils.py::test_value_kind[Dataclass-ValueKind.VALUE] tests/test_utils.py::test_value_kind[???-ValueKind.MANDATORY_MISSING] tests/test_utils.py::test_value_kind[${foo.bar}-ValueKind.INTERPOLATION] tests/test_utils.py::test_value_kind[ftp://${host}/path-ValueKind.STR_INTERPOLATION] tests/test_utils.py::test_value_kind[${func:foo}-ValueKind.INTERPOLATION] tests/test_utils.py::test_value_kind[${func:a/b}-ValueKind.INTERPOLATION] tests/test_utils.py::test_value_kind[${func:c:\\a\\b}-ValueKind.INTERPOLATION0] tests/test_utils.py::test_value_kind[${func:c:\\a\\b}-ValueKind.INTERPOLATION1] tests/test_utils.py::test_re_parent tests/test_utils.py::test_get_class tests/test_utils.py::test_get_key_value_types[int-int-int-KeyValidationError] tests/test_utils.py::test_get_key_value_types[int-int-str-str] tests/test_utils.py::test_get_key_value_types[int-int-Color-Color] tests/test_utils.py::test_get_key_value_types[int-int-key_type3-None] tests/test_utils.py::test_get_key_value_types[int-int-None-KeyValidationError] tests/test_utils.py::test_get_key_value_types[str-str-int-KeyValidationError] tests/test_utils.py::test_get_key_value_types[str-str-str-str] tests/test_utils.py::test_get_key_value_types[str-str-Color-Color] tests/test_utils.py::test_get_key_value_types[str-str-key_type3-None] tests/test_utils.py::test_get_key_value_types[str-str-None-KeyValidationError] tests/test_utils.py::test_get_key_value_types[Color-Color-int-KeyValidationError] tests/test_utils.py::test_get_key_value_types[Color-Color-str-str] tests/test_utils.py::test_get_key_value_types[Color-Color-Color-Color] tests/test_utils.py::test_get_key_value_types[Color-Color-key_type3-None] tests/test_utils.py::test_get_key_value_types[Color-Color-None-KeyValidationError] tests/test_utils.py::test_get_key_value_types[value_type3-None-int-KeyValidationError] tests/test_utils.py::test_get_key_value_types[value_type3-None-str-str] tests/test_utils.py::test_get_key_value_types[value_type3-None-Color-Color] tests/test_utils.py::test_get_key_value_types[value_type3-None-key_type3-None] tests/test_utils.py::test_get_key_value_types[value_type3-None-None-KeyValidationError] tests/test_utils.py::test_get_key_value_types[None-NoneType-int-KeyValidationError] tests/test_utils.py::test_get_key_value_types[None-NoneType-str-str] tests/test_utils.py::test_get_key_value_types[None-NoneType-Color-Color] tests/test_utils.py::test_get_key_value_types[None-NoneType-key_type3-None] tests/test_utils.py::test_get_key_value_types[None-NoneType-None-KeyValidationError] tests/test_utils.py::test_is_primitive_type[int-True] tests/test_utils.py::test_is_primitive_type[float-True] tests/test_utils.py::test_is_primitive_type[bool-True] tests/test_utils.py::test_is_primitive_type[str-True] tests/test_utils.py::test_is_primitive_type[NoneType-True] tests/test_utils.py::test_is_primitive_type[Color-True] tests/test_utils.py::test_is_primitive_type[list-False] tests/test_utils.py::test_is_primitive_type[ListConfig-False] tests/test_utils.py::test_is_primitive_type[dict-False] tests/test_utils.py::test_is_primitive_type[DictConfig-False] tests/test_utils.py::test_type_str[int-int-False] tests/test_utils.py::test_type_str[int-int-True] tests/test_utils.py::test_type_str[bool-bool-False] tests/test_utils.py::test_type_str[bool-bool-True] tests/test_utils.py::test_type_str[float-float-False] tests/test_utils.py::test_type_str[float-float-True] tests/test_utils.py::test_type_str[str-str-False] tests/test_utils.py::test_type_str[str-str-True] tests/test_utils.py::test_type_str[Color-Color-False] tests/test_utils.py::test_type_str[Color-Color-True] tests/test_utils.py::test_type_str[DictConfig-DictConfig-False] tests/test_utils.py::test_type_str[DictConfig-DictConfig-True] tests/test_utils.py::test_type_str[ListConfig-ListConfig-False] tests/test_utils.py::test_type_str[ListConfig-ListConfig-True] tests/test_utils.py::test_type_str[type_7-Dict[str, tests/test_utils.py::test_type_str[type_8-Dict[Color, tests/test_utils.py::test_type_str[type_9-Dict[str, tests/test_utils.py::test_type_str[type_10-Dict[str, tests/test_utils.py::test_type_str[type_11-List[str]-False] tests/test_utils.py::test_type_str[type_11-List[str]-True] tests/test_utils.py::test_type_str[type_12-List[Color]-False] tests/test_utils.py::test_type_str[type_12-List[Color]-True] tests/test_utils.py::test_type_str[type_13-List[Dict[str, tests/test_utils.py::test_type_str_union[type_0-Optional[int]] tests/test_utils.py::test_type_str_union[type_1-Union[str, tests/test_utils.py::test_type_str_union[type_2-Optional[int]] tests/test_utils.py::test_type_str_union[type_3-Union[int, tests/test_utils.py::test_is_dict_annotation[type_0-True] tests/test_utils.py::test_is_dict_annotation[type_1-True] tests/test_utils.py::test_is_dict_annotation[type_2-True] tests/test_utils.py::test_is_dict_annotation[type_3-True] tests/test_utils.py::test_is_dict_annotation[type_4-True] tests/test_utils.py::test_is_dict_annotation[type_5-True] tests/test_utils.py::test_is_dict_annotation[type_6-True] tests/test_utils.py::test_is_dict_annotation[type_7-True] tests/test_utils.py::test_is_dict_annotation[type_8-False] tests/test_utils.py::test_is_dict_annotation[dict-False] tests/test_utils.py::test_is_dict_annotation[DictConfig-False] tests/test_utils.py::test_is_list_annotation[type_0-True] tests/test_utils.py::test_is_list_annotation[type_1-True] tests/test_utils.py::test_is_list_annotation[type_2-True] tests/test_utils.py::test_is_list_annotation[type_3-True] tests/test_utils.py::test_is_list_annotation[type_4-True] tests/test_utils.py::test_is_list_annotation[type_5-True] tests/test_utils.py::test_is_list_annotation[type_6-True] tests/test_utils.py::test_is_list_annotation[type_7-False] tests/test_utils.py::test_is_list_annotation[type_8-True] tests/test_utils.py::test_is_list_annotation[list-False] tests/test_utils.py::test_is_list_annotation[tuple-False] tests/test_utils.py::test_is_list_annotation[ListConfig-False] tests/test_utils.py::test_get_ref_type[int] tests/test_utils.py::test_get_ref_type[float] tests/test_utils.py::test_get_ref_type[bool] tests/test_utils.py::test_get_ref_type[str] tests/test_utils.py::test_get_ref_type[NoneType] tests/test_utils.py::test_get_ref_type[dict] tests/test_utils.py::test_get_ref_type[List[Any]0] tests/test_utils.py::test_get_ref_type[List[Any]1] tests/test_utils.py::test_get_ref_type[ConcretePlugin0] tests/test_utils.py::test_get_ref_type[ConcretePlugin1] tests/test_utils.py::test_get_ref_type[IntegerNode0] tests/test_utils.py::test_get_ref_type[FloatNode0] tests/test_utils.py::test_get_ref_type[BooleanNode0] tests/test_utils.py::test_get_ref_type[StringNode0] tests/test_utils.py::test_get_ref_type[EnumNode[Color]0] tests/test_utils.py::test_get_ref_type[IntegerNode1] tests/test_utils.py::test_get_ref_type[FloatNode1] tests/test_utils.py::test_get_ref_type[BooleanNode1] tests/test_utils.py::test_get_ref_type[StringNode1] tests/test_utils.py::test_get_ref_type[EnumNode[Color]1] tests/test_utils.py::test_get_ref_type[DictConfig] tests/test_utils.py::test_get_ref_type[DictConfig[int,Color]] tests/test_utils.py::test_get_ref_type[DictConfig[Color,int]] tests/test_utils.py::test_get_ref_type[DictConfig[ConcretePlugin]_Any_reftype] tests/test_utils.py::test_get_ref_type[DictConfig[Plugin]] tests/test_utils.py::test_get_ref_type[Plugin0] tests/test_utils.py::test_get_ref_type[Plugin1] tests/test_utils.py::test_get_ref_type[ListConfig[Any]] tests/test_utils.py::test_get_ref_type[ListConfig[int]]
omegaconf/dictconfig.py omegaconf/listconfig.py omegaconf/omegaconf.py omegaconf/base.py omegaconf/_utils.py omegaconf/basecontainer.py .coveragerc
omegaconf/dictconfig.py omegaconf/listconfig.py omegaconf/omegaconf.py omegaconf/base.py omegaconf/_utils.py omegaconf/basecontainer.py .coveragerc