code: def test_nested(self, a_dtype, bc_dtype, bd_dtype):
      self.assertFeatureEagerOnly(
          feature=feature_lib.Dataset(
              {
                  "a": a_dtype,
                  "b": {
                      "c": feature_lib.Tensor(
                          shape=(4, 2), dtype=bc_dtype
                      ),
                      "d": bd_dtype,
                  },
              },
              length=None,
          ),
          shape={
              "a": (),
              "b": {
                  "c": (4, 2),
                  "d": (),
              },
          },
          dtype={
              "a": np.object_,
              "b": {
                  "c": np.int32,
                  "d": np.uint8,
              },
          },
          tests=[
              testing.FeatureExpectationItem(
                  value=dataset_utils.as_numpy(
                      tf.data.Dataset.from_tensor_slices(
                          {
                              "a": ["aa", "b", "ccc"],
                              "b": {
                                  "c": np.ones(
                                      shape=(3, 4, 2), dtype=np.int32
                                  ),
                                  "d": [1, 2, 3],
                              },
                          }
                      )
                  ),
                  expected=tf.data.Dataset.from_tensor_slices(
                      {
                          "a": [
                              tf.compat.as_bytes(t)
                              for t in ("aa", "b", "ccc")
                          ],
                          "b": {
                              "c": np.ones(
                                  shape=(3, 4, 2), dtype=np.int32
                              ),
                              "d": [1, 2, 3],
                          },
                      }
                  ),
                  expected_np=[
                      {
                          "a": b"aa",
                          "b": {
                              "c": np.ones(
                                  shape=(4, 2), dtype=np.int32
                              ),
                              "d": 1,
                          },
                      },
                      {
                          "a": b"b",
                          "b": {
                              "c": np.ones(
                                  shape=(4, 2), dtype=np.int32
                              ),
                              "d": 2,
                          },
                      },
                      {
                          "a": b"ccc",
                          "b": {
                              "c": np.ones(
                                  shape=(4, 2), dtype=np.int32
                              ),
                              "d": 3,
                          },
                      },
                  ],
              ),
              testing.FeatureExpectationItem(
                  value=dataset_utils.as_numpy(
                      tf.data.Dataset.from_tensor_slices(
                          {
                              "a": [str(i) for i in range(100)],
                              "b": {  # pylint: disable=g-complex-comprehension
                                  "c": [
                                      np.ones(
                                          shape=(4, 2), dtype=np.int32
                                      )
                                      for _ in range(100)
                                  ],
                                  "d": [5 for _ in range(100)],
                              },
                          }
                      )
                  ),
                  expected=tf.data.Dataset.from_tensor_slices(
                      {
                          "a": [
                              tf.compat.as_bytes(str(i))
                              for i in range(100)
                          ],
                          "b": {
                              "c": np.ones(
                                  shape=(100, 4, 2), dtype=np.int32
                              ),
                              "d": [5] * 100,
                          },
                      }
                  ),
                  expected_np=[
                      {
                          "a": str(i).encode(),
                          "b": {
                              "c": np.ones(
                                  shape=(4, 2), dtype=np.int32
                              ),
                              "d": 5,
                          },
                      }
                      for i in range(100)
                  ],
              ),
          ],
      )
  
imports: import pickle
  from absl.testing import parameterized
  import numpy
  import tensorflow
  from tensorflow_datasets import testing
  from tensorflow_datasets.core import dataset_utils
  from tensorflow_datasets.core import decode
  from tensorflow_datasets.core import features
label_desc: Use image node_id 3 for calling the DatasetDictFeatureTest obj's underlying member method code with example usage: obj.test_nested(a_dtype, bc_dtype, bd_dtype) without return types