code: def test_IDListFeatures_and_IDScoreListFeatures(self) -> None:
      ID_LIST_FEATURE_ID = 0
      ID_SCORE_LIST_FEATURE_ID = 1
      EMBEDDING_TABLE_SIZE = 100
      EMBEDDING_DIM = 128
      data = {
          InputColumn.STATE_ID_LIST_FEATURES: {
              ID_LIST_FEATURE_ID: [
                  torch.tensor([0, 3]),
                  torch.tensor([0, 1, 2, 3, 4]),
              ]
          },
          InputColumn.NEXT_STATE_ID_LIST_FEATURES: {
              ID_LIST_FEATURE_ID: [
                  torch.tensor([0, 1]),
                  torch.tensor([0, 1]),
              ]
          },
          InputColumn.STATE_ID_SCORE_LIST_FEATURES: {
              ID_SCORE_LIST_FEATURE_ID: [
                  torch.tensor([0, 3]),
                  torch.tensor([0, 1, 2, 3, 4]),
                  torch.tensor([0.0, 0.1, 0.2, 0.3, 0.4]),
              ]
          },
          InputColumn.NEXT_STATE_ID_SCORE_LIST_FEATURES: {
              ID_SCORE_LIST_FEATURE_ID: [
                  torch.tensor([0, 2]),
                  torch.tensor([0, 1, 2]),
                  torch.tensor([0.0, 0.1, 0.2]),
              ]
          },
      }
      state_feature_config = rlt.ModelFeatureConfig(
          float_feature_infos=[],
          id_list_feature_configs=[
              rlt.IdListFeatureConfig(
                  name=f"id_list_feature_{ID_LIST_FEATURE_ID}",
                  feature_id=ID_LIST_FEATURE_ID,
                  id_mapping_name=f"id_list_feature_table_{ID_LIST_FEATURE_ID}",
              )
          ],
          id_score_list_feature_configs=[
              rlt.IdScoreListFeatureConfig(
                  name=f"id_score_list_feature_{ID_SCORE_LIST_FEATURE_ID}",
                  feature_id=ID_SCORE_LIST_FEATURE_ID,
                  id_mapping_name=f"id_score_list_feature_table_{ID_SCORE_LIST_FEATURE_ID}",
              )
          ],
          id_mapping_config={
              f"id_list_feature_table_{ID_LIST_FEATURE_ID}": rlt.IdMappingConfig(
                  embedding_table_size=EMBEDDING_TABLE_SIZE,
                  embedding_dim=EMBEDDING_DIM,
                  hashing=False,
              ),
              f"id_score_list_feature_table_{ID_SCORE_LIST_FEATURE_ID}": rlt.IdMappingConfig(
                  embedding_table_size=EMBEDDING_TABLE_SIZE,
                  embedding_dim=EMBEDDING_DIM,
                  hashing=False,
              ),
          },
      )
  
      state_id_list_columns: List[str] = [
          InputColumn.STATE_ID_LIST_FEATURES,
          InputColumn.NEXT_STATE_ID_LIST_FEATURES,
      ]
      state_id_score_list_columns: List[str] = [
          InputColumn.STATE_ID_SCORE_LIST_FEATURES,
          InputColumn.NEXT_STATE_ID_SCORE_LIST_FEATURES,
      ]
  
      transform_id_list_features = transforms.IDListFeatures(
          keys=state_id_list_columns,
          # both columns share the same feature configs
          feature_configs=[
              state_feature_config.id_list_feature_configs,
              state_feature_config.id_list_feature_configs,
          ],
          id_mapping_configs=[
              state_feature_config.id_mapping_config,
              state_feature_config.id_mapping_config,
          ],
      )
  
      transform_id_score_list_features = transforms.IDScoreListFeatures(
          keys=state_id_score_list_columns,
          feature_configs=[
              state_feature_config.id_score_list_feature_configs,
              state_feature_config.id_score_list_feature_configs,
          ],
          id_mapping_configs=[
              state_feature_config.id_mapping_config,
              state_feature_config.id_mapping_config,
          ],
      )
      out = transform_id_score_list_features(
          transform_id_list_features(deepcopy(data))
      )
  
      for column in [
          InputColumn.STATE_ID_SCORE_LIST_FEATURES,
          InputColumn.NEXT_STATE_ID_SCORE_LIST_FEATURES,
      ]:
          self.assertEqual(
              out[column].keys(),
              [
                  x.name
                  for x in state_feature_config.id_score_list_feature_configs
              ],
          )
          assert torch.allclose(
              out[column].values(),
              data[column][ID_SCORE_LIST_FEATURE_ID][1],
          )
          assert torch.allclose(
              out[column].weights(),
              data[column][ID_SCORE_LIST_FEATURE_ID][2],
          )
          assert torch.allclose(
              # KeyedJaggedTensor's offset has one more element at the end
              out[column].offsets()[:-1],
              data[column][ID_SCORE_LIST_FEATURE_ID][0],
          )
  
      for column in [
          InputColumn.STATE_ID_LIST_FEATURES,
          InputColumn.NEXT_STATE_ID_LIST_FEATURES,
      ]:
          self.assertEqual(
              out[column].keys(),
              [
                  x.name
                  for x in state_feature_config.id_list_feature_configs
              ],
          )
          assert torch.allclose(
              out[column].values(),
              data[column][ID_LIST_FEATURE_ID][1],
          )
          assert torch.allclose(
              # KeyedJaggedTensor's offset has one more element at the end
              out[column].offsets()[:-1],
              data[column][ID_LIST_FEATURE_ID][0],
          )
  
imports: import os
  import unittest
  from copy import deepcopy
  from typing import List
  from unittest.mock import Mock, patch
  import numpy
  import reagent.core.types
  import torch
  from reagent.preprocessing import transforms
  from reagent.preprocessing.types import InputColumn
label_desc: Use image node_id 15 for calling the TestTransforms obj's underlying member method code with example usage: obj.test_IDListFeatures_and_IDScoreListFeatures() without return types