isaacscript-common 87.9.5 → 87.9.7

package/src/functions/deepCopyTests.ts

@@ -43,181 +43,157 @@ export function runDeepCopyTests(): void {
   print(successText);
 }
 
-function copiedObjectIsTable() {
-  const oldObject = {
-    abc: "def",
-  };
-  const newObject = deepCopy(
-    oldObject,
-    SerializationType.NONE,
-    "copiedObjectIsTable",
-  );
-  if (!isTable(newObject)) {
-    error(`The copied object had a type of: ${typeof newObject}`);
-  }
-}
-
-function copiedObjectHasKeyAndValueString() {
-  const keyToLookFor = "abc";
-  const valueToLookFor = "def";
-  const oldObject = {
-    abc: valueToLookFor,
-  };
-  const newObject = deepCopy(
-    oldObject,
-    SerializationType.NONE,
-    "copiedObjectHasKeyAndValueString",
-  );
+function copiedDefaultMapHasBrand() {
+  const oldDefaultValue = "foo";
+  const oldDefaultMap = new DefaultMap<string, string>(oldDefaultValue);
+  const newTable = deepCopy(
+    oldDefaultMap,
+    SerializationType.SERIALIZE,
+    "copiedDefaultMapHasBrand",
+  ) as LuaMap<AnyNotNil, unknown>;
 
-  const value = newObject[keyToLookFor] as string | undefined;
-  if (value === undefined) {
-    error(`The copied object did not have a key of: ${keyToLookFor}`);
+  if (!isTable(newTable)) {
+    error(
+      `The copied DefaultMap was not a table and had a type of: ${typeof newTable}`,
+    );
   }
 
-  if (!isString(value)) {
-    error(`The copied object had a value type of: ${typeof value}`);
-  }
-  if (value !== valueToLookFor) {
-    error(`The copied object had a value of: ${value}`);
+  if (!newTable.has(SerializationBrand.DEFAULT_MAP)) {
+    error(
+      `The copied DefaultMap does not have the brand: ${SerializationBrand.DEFAULT_MAP}`,
+    );
   }
 }
 
-function copiedTableHasKeyAndValueNumber() {
-  const keyToLookFor = 123;
-  const valueToLookFor = 456;
-  const oldTable = new LuaMap<AnyNotNil, unknown>();
-  oldTable.set(keyToLookFor, valueToLookFor);
+function copiedDefaultMapHasChildDefaultMap() {
+  const parentMapKey = "abc";
+  const childMapKey1 = 123;
+  const childMapKey2 = 456;
+  const childMapDefaultValue = 1;
+  const childMapCustomValue = 2;
+  const oldParentMap = new DefaultMap<string, DefaultMap<number, number>>(
+    () => new DefaultMap(childMapDefaultValue),
+  );
+  const oldChildMap = oldParentMap.getAndSetDefault(parentMapKey);
+  oldChildMap.getAndSetDefault(childMapKey1);
+  oldChildMap.set(childMapKey2, childMapCustomValue);
 
-  const newTable = deepCopy(
-    oldTable,
+  const newParentMap = deepCopy(
+    oldParentMap,
     SerializationType.NONE,
-    "copiedTableHasKeyAndValueNumber",
+    "copiedDefaultMapHasChildDefaultMap",
   );
 
-  const value = newTable.get(keyToLookFor) as number | undefined;
-  if (value === undefined) {
-    error(`The copied object did not have a key of: ${keyToLookFor}`);
+  if (!isDefaultMap(newParentMap)) {
+    error(
+      `The copied parent DefaultMap was not a DefaultMap and had a type of: ${typeof newParentMap}`,
+    );
   }
 
-  if (!isNumber(value)) {
-    error(`The copied object had a value type of: ${typeof value}`);
-  }
-  if (value !== valueToLookFor) {
-    error(`The copied object had a value of: ${value}`);
+  const newChildMap = newParentMap.get(parentMapKey);
+  if (newChildMap === undefined) {
+    error(
+      `The copied DefaultMap did not have a child map at key: ${parentMapKey}`,
+    );
   }
-}
-
-function copiedTableDoesNotCoerceTypes() {
-  const keyToLookFor = 123;
-  const valueToLookFor = 456;
-  const oldTable = new LuaMap<AnyNotNil, unknown>();
-  oldTable.set(keyToLookFor, valueToLookFor);
-
-  const newTable = deepCopy(
-    oldTable,
-    SerializationType.NONE,
-    "copiedTableDoesNotCoerceTypes",
-  );
 
-  const keyString = tostring(keyToLookFor);
-  const valueString = tostring(valueToLookFor);
+  if (!isDefaultMap(newChildMap)) {
+    error(
+      `The copied child DefaultMap was not a DefaultMap and had a type of: ${typeof newChildMap}`,
+    );
+  }
 
-  const valueFromString = newTable.get(keyString);
-  if (valueFromString !== undefined) {
-    error(`The copied object had a string key of: ${keyString}`);
+  const newChildMapValue1 = newChildMap.get(childMapKey1);
+  if (newChildMapValue1 === undefined) {
+    error(`The copied child DefaultMap did not have a key of: ${childMapKey1}`);
+  }
+  if (newChildMapValue1 !== childMapDefaultValue) {
+    error(
+      `The copied child Map did not have a default value of: ${childMapDefaultValue}`,
+    );
   }
 
-  const value = newTable.get(keyToLookFor);
-  if (value === valueString) {
+  const newChildMapValue2 = newChildMap.get(childMapKey2);
+  if (newChildMapValue2 === undefined) {
+    error(`The copied child DefaultMap did not have a key of: ${childMapKey2}`);
+  }
+  if (newChildMapValue2 !== childMapCustomValue) {
     error(
-      `The copied object had a value that incorrectly matched the string of: ${valueString}`,
+      `The copied child Map did not have a custom value of: ${childMapCustomValue}`,
     );
   }
 }
 
-/** In this context, a reference is a pointer. */
-function copiedObjectHasNoReferencesForPrimitivesForward() {
-  const originalStringValue = "abcdef";
-  const originalNumberValue = 123;
-  const oldObject = {
-    abc: originalStringValue,
-    def: originalNumberValue,
-  };
-  const newObject = deepCopy(
-    oldObject,
+function copiedMapHasChildMap() {
+  const childMapKey = 123;
+  const childMapValue = 456;
+  const oldChildMap = new Map<number, number>([[childMapKey, childMapValue]]);
+
+  const keyToLookFor = "childMap";
+  const oldMap = new Map<string, Map<number, number>>([
+    [keyToLookFor, oldChildMap],
+  ]);
+
+  const newMap = deepCopy(
+    oldMap,
     SerializationType.NONE,
-    "copiedObjectHasNoReferencesForPrimitivesForward",
+    "copiedMapHasChildMap",
   );
 
-  oldObject.abc = "newValue";
-  if (oldObject.abc === newObject.abc) {
-    error("The copied object has a string reference going forward.");
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and had a type of: ${typeof newMap}`);
   }
 
-  oldObject.def = 456;
-  if (oldObject.def === newObject.def) {
-    error("The copied object has a number reference going forward.");
+  const newChildMap = newMap.get(keyToLookFor);
+  if (newChildMap === undefined) {
+    error(`The copied Map did not have a child map at key: ${keyToLookFor}`);
   }
-}
-
-function copiedObjectHasNoReferencesForPrimitivesBackward() {
-  const originalStringValue = "abcdef";
-  const originalNumberValue = 123;
-  const oldObject = {
-    abc: originalStringValue,
-    def: originalNumberValue,
-  };
-  const newObject = deepCopy(
-    oldObject,
-    SerializationType.NONE,
-    "copiedObjectHasNoReferencesForPrimitivesBackward",
-  );
 
-  newObject.abc = "newValue";
-  if (newObject.abc === oldObject.abc) {
-    error("The copied object has a string reference going backward.");
+  if (!isTSTLMap(newChildMap)) {
+    error(
+      `The copied child Map was not a Map and had a type of: ${typeof newChildMap}`,
+    );
   }
 
-  newObject.def = 456;
-  if (newObject.def === oldObject.def) {
-    error("The copied object has a number reference going backward.");
+  const value = newChildMap.get(childMapKey);
+  if (value === undefined) {
+    error(`The copied child Map did not have a key of: ${childMapKey}`);
+  }
+  if (value !== childMapValue) {
+    error(`The copied child Map did not have a value of: ${childMapValue}`);
   }
 }
 
-/** In this context, a reference is a pointer. */
-function copiedObjectHasNoReferencesForArray() {
-  const oldObject = {
-    abc: [1, 2, 3],
-  };
-  const newObject = deepCopy(
-    oldObject,
-    SerializationType.NONE,
-    "copiedObjectHasNoReferencesForArray",
-  );
+function copiedMapHasValue() {
+  const keyToLookFor = "abc";
+  const valueToLookFor = "def";
+  const oldMap = new Map<string, string>([[keyToLookFor, valueToLookFor]]);
 
-  if (oldObject.abc === newObject.abc) {
-    error("The copied object has the same point to the child array.");
-  }
+  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapHasValue");
 
-  if (!arrayEquals(oldObject.abc, newObject.abc)) {
-    error("The copied object does not have an equal array.");
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
   }
 
-  oldObject.abc[0]!++; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-  if (arrayEquals(oldObject.abc, newObject.abc)) {
-    error(
-      "The copied object has an equal array after a modification to the old array.",
-    );
+  const value = newMap.get(keyToLookFor);
+  if (value === undefined) {
+    error(`The copied Map did not have a key of: ${keyToLookFor}`);
   }
-  oldObject.abc[0]!--; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+  if (value !== valueToLookFor) {
+    error(`The copied Map did not have a value of: ${valueToLookFor}`);
+  }
+}
 
-  newObject.abc[0]!++; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-  if (arrayEquals(oldObject.abc, newObject.abc)) {
-    error(
-      "The copied object has an equal array after a modification to the new array.",
-    );
+function copiedMapIsMap() {
+  const keyToLookFor = "abc";
+  const valueToLookFor = "def";
+  const oldMap = new Map<string, string>([[keyToLookFor, valueToLookFor]]);
+
+  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
+
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
   }
-  newObject.abc[0]!--; // eslint-disable-line @typescript-eslint/no-non-null-assertion
 }
 
 function copiedObjectHasChildObject() {
@@ -236,8 +212,7 @@ function copiedObjectHasChildObject() {
   );
 
   const childObject = newObject[childObjectIndex] as
-    | (typeof oldObject)["abc"]
-    | undefined;
+    (typeof oldObject)["abc"] | undefined;
   if (childObject === undefined) {
     error(`Failed to find the child object at index: ${childObjectIndex}`);
   }
@@ -259,208 +234,172 @@ function copiedObjectHasChildObject() {
   }
 }
 
-function copiedMapIsMap() {
-  const keyToLookFor = "abc";
-  const valueToLookFor = "def";
-  const oldMap = new Map<string, string>([[keyToLookFor, valueToLookFor]]);
-
-  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
-
-  if (!isTSTLMap(newMap)) {
-    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
-  }
-}
-
-function copiedMapHasValue() {
+function copiedObjectHasKeyAndValueString() {
   const keyToLookFor = "abc";
   const valueToLookFor = "def";
-  const oldMap = new Map<string, string>([[keyToLookFor, valueToLookFor]]);
-
-  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapHasValue");
-
-  if (!isTSTLMap(newMap)) {
-    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
-  }
-
-  const value = newMap.get(keyToLookFor);
-  if (value === undefined) {
-    error(`The copied Map did not have a key of: ${keyToLookFor}`);
-  }
-  if (value !== valueToLookFor) {
-    error(`The copied Map did not have a value of: ${valueToLookFor}`);
-  }
-}
-
-function copiedSetIsSet() {
-  const valueToLookFor = "abc";
-  const oldSet = new Set<string>([valueToLookFor]);
-
-  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
-
-  if (!isTSTLSet(newSet)) {
-    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
-  }
-}
-
-function copiedSetHasValue() {
-  const valueToLookFor = "abc";
-  const oldSet = new Set<string>([valueToLookFor]);
-
-  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetHasValue");
-
-  if (!isTSTLSet(newSet)) {
-    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
-  }
-
-  const hasValue = newSet.has(valueToLookFor);
-  if (!hasValue) {
-    error(`The copied Set did not have a value of: ${valueToLookFor}`);
-  }
-}
-
-function copiedMapHasChildMap() {
-  const childMapKey = 123;
-  const childMapValue = 456;
-  const oldChildMap = new Map<number, number>([[childMapKey, childMapValue]]);
-
-  const keyToLookFor = "childMap";
-  const oldMap = new Map<string, Map<number, number>>([
-    [keyToLookFor, oldChildMap],
-  ]);
-
-  const newMap = deepCopy(
-    oldMap,
+  const oldObject = { abc: valueToLookFor };
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
-    "copiedMapHasChildMap",
+    "copiedObjectHasKeyAndValueString",
   );
 
-  if (!isTSTLMap(newMap)) {
-    error(`The copied Map was not a Map and had a type of: ${typeof newMap}`);
-  }
-
-  const newChildMap = newMap.get(keyToLookFor);
-  if (newChildMap === undefined) {
-    error(`The copied Map did not have a child map at key: ${keyToLookFor}`);
-  }
-
-  if (!isTSTLMap(newChildMap)) {
-    error(
-      `The copied child Map was not a Map and had a type of: ${typeof newChildMap}`,
-    );
+  const value = newObject[keyToLookFor] as string | undefined;
+  if (value === undefined) {
+    error(`The copied object did not have a key of: ${keyToLookFor}`);
   }
 
-  const value = newChildMap.get(childMapKey);
-  if (value === undefined) {
-    error(`The copied child Map did not have a key of: ${childMapKey}`);
+  if (!isString(value)) {
+    error(`The copied object had a value type of: ${typeof value}`);
   }
-  if (value !== childMapValue) {
-    error(`The copied child Map did not have a value of: ${childMapValue}`);
+  if (value !== valueToLookFor) {
+    error(`The copied object had a value of: ${value}`);
   }
 }
 
-function copiedDefaultMapHasChildDefaultMap() {
-  const parentMapKey = "abc";
-  const childMapKey1 = 123;
-  const childMapKey2 = 456;
-  const childMapDefaultValue = 1;
-  const childMapCustomValue = 2;
-  const oldParentMap = new DefaultMap<string, DefaultMap<number, number>>(
-    () => new DefaultMap(childMapDefaultValue),
-  );
-  const oldChildMap = oldParentMap.getAndSetDefault(parentMapKey);
-  oldChildMap.getAndSetDefault(childMapKey1);
-  oldChildMap.set(childMapKey2, childMapCustomValue);
-
-  const newParentMap = deepCopy(
-    oldParentMap,
+/** In this context, a reference is a pointer. */
+function copiedObjectHasNoReferencesForArray() {
+  const oldObject = { abc: [1, 2, 3] };
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
-    "copiedDefaultMapHasChildDefaultMap",
+    "copiedObjectHasNoReferencesForArray",
   );
 
-  if (!isDefaultMap(newParentMap)) {
-    error(
-      `The copied parent DefaultMap was not a DefaultMap and had a type of: ${typeof newParentMap}`,
-    );
+  if (oldObject.abc === newObject.abc) {
+    error("The copied object has the same point to the child array.");
   }
 
-  const newChildMap = newParentMap.get(parentMapKey);
-  if (newChildMap === undefined) {
+  if (!arrayEquals(oldObject.abc, newObject.abc)) {
+    error("The copied object does not have an equal array.");
+  }
+
+  oldObject.abc[0]!++; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+  if (arrayEquals(oldObject.abc, newObject.abc)) {
     error(
-      `The copied DefaultMap did not have a child map at key: ${parentMapKey}`,
+      "The copied object has an equal array after a modification to the old array.",
     );
   }
+  oldObject.abc[0]!--; // eslint-disable-line @typescript-eslint/no-non-null-assertion
 
-  if (!isDefaultMap(newChildMap)) {
+  newObject.abc[0]!++; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+  if (arrayEquals(oldObject.abc, newObject.abc)) {
     error(
-      `The copied child DefaultMap was not a DefaultMap and had a type of: ${typeof newChildMap}`,
+      "The copied object has an equal array after a modification to the new array.",
     );
   }
+  newObject.abc[0]!--; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+}
 
-  const newChildMapValue1 = newChildMap.get(childMapKey1);
-  if (newChildMapValue1 === undefined) {
-    error(`The copied child DefaultMap did not have a key of: ${childMapKey1}`);
+function copiedObjectHasNoReferencesForPrimitivesBackward() {
+  const originalStringValue = "abcdef";
+  const originalNumberValue = 123;
+  const oldObject = {
+    abc: originalStringValue,
+    def: originalNumberValue,
+  };
+  const newObject = deepCopy(
+    oldObject,
+    SerializationType.NONE,
+    "copiedObjectHasNoReferencesForPrimitivesBackward",
+  );
+
+  newObject.abc = "newValue";
+  if (newObject.abc === oldObject.abc) {
+    error("The copied object has a string reference going backward.");
   }
-  if (newChildMapValue1 !== childMapDefaultValue) {
-    error(
-      `The copied child Map did not have a default value of: ${childMapDefaultValue}`,
-    );
+
+  newObject.def = 456;
+  if (newObject.def === oldObject.def) {
+    error("The copied object has a number reference going backward.");
   }
+}
 
-  const newChildMapValue2 = newChildMap.get(childMapKey2);
-  if (newChildMapValue2 === undefined) {
-    error(`The copied child DefaultMap did not have a key of: ${childMapKey2}`);
+/** In this context, a reference is a pointer. */
+function copiedObjectHasNoReferencesForPrimitivesForward() {
+  const originalStringValue = "abcdef";
+  const originalNumberValue = 123;
+  const oldObject = {
+    abc: originalStringValue,
+    def: originalNumberValue,
+  };
+  const newObject = deepCopy(
+    oldObject,
+    SerializationType.NONE,
+    "copiedObjectHasNoReferencesForPrimitivesForward",
+  );
+
+  oldObject.abc = "newValue";
+  if (oldObject.abc === newObject.abc) {
+    error("The copied object has a string reference going forward.");
   }
-  if (newChildMapValue2 !== childMapCustomValue) {
-    error(
-      `The copied child Map did not have a custom value of: ${childMapCustomValue}`,
-    );
+
+  oldObject.def = 456;
+  if (oldObject.def === newObject.def) {
+    error("The copied object has a number reference going forward.");
   }
 }
 
-function copiedDefaultMapHasBrand() {
-  const oldDefaultValue = "foo";
-  const oldDefaultMap = new DefaultMap<string, string>(oldDefaultValue);
-  const newTable = deepCopy(
+function copiedObjectIsTable() {
+  const oldObject = { abc: "def" };
+  const newObject = deepCopy(
+    oldObject,
+    SerializationType.NONE,
+    "copiedObjectIsTable",
+  );
+  if (!isTable(newObject)) {
+    error(`The copied object had a type of: ${typeof newObject}`);
+  }
+}
+
+function copiedSerializedDefaultMapHasNumberKey() {
+  const mapKey = 123;
+  const oldDefaultMap = new DefaultMap<number, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
+
+  const serializedOldDefaultMap = deepCopy(
     oldDefaultMap,
     SerializationType.SERIALIZE,
-    "copiedDefaultMapHasBrand",
-  ) as LuaMap<AnyNotNil, unknown>;
+    "copiedSerializedDefaultMapHasNumberKey-serialize",
+  );
 
-  if (!isTable(newTable)) {
-    error(
-      `The copied DefaultMap was not a table and had a type of: ${typeof newTable}`,
-    );
-  }
+  const newTable = deepCopy(
+    serializedOldDefaultMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKey-deserialize",
+  );
 
-  if (!newTable.has(SerializationBrand.DEFAULT_MAP)) {
+  const newDefaultMap = newTable as DefaultMap<number, number>;
+  if (!newDefaultMap.has(mapKey)) {
+    const keyType = type(mapKey);
     error(
-      `The copied DefaultMap does not have the brand: ${SerializationBrand.DEFAULT_MAP}`,
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${keyType}`,
     );
   }
 }
 
-function copiedSerializedMapHasStringKey() {
+function copiedSerializedDefaultMapHasStringKey() {
   const mapKey = "123";
-  const mapValue = 456;
-  const oldMap = new Map<string, number>([[mapKey, mapValue]]);
+  const oldDefaultMap = new DefaultMap<string, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
 
-  const serializedOldMap = deepCopy(
-    oldMap,
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedMapHasStringKey-serialize",
+    "copiedSerializedDefaultMapHasStringKey-serialize",
   );
 
   const newTable = deepCopy(
-    serializedOldMap,
+    serializedOldDefaultMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedMapHasStringKey-deserialize",
+    "copiedSerializedDefaultMapHasStringKey-deserialize",
   );
 
-  const newMap = newTable as Map<string, number>;
-  if (!newMap.has(mapKey)) {
+  const newDefaultMap = newTable as DefaultMap<string, number>;
+  if (!newDefaultMap.has(mapKey)) {
     const keyType = type(mapKey);
     error(
-      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
+      `The copied DefaultMap did not have a key of "${mapKey}" with type: ${keyType}`,
     );
   }
 }
@@ -491,54 +430,108 @@ function copiedSerializedMapHasNumberKey() {
   }
 }
 
-function copiedSerializedDefaultMapHasStringKey() {
+function copiedSerializedMapHasStringKey() {
   const mapKey = "123";
-  const oldDefaultMap = new DefaultMap<string, number>(456);
-  oldDefaultMap.getAndSetDefault(mapKey);
+  const mapValue = 456;
+  const oldMap = new Map<string, number>([[mapKey, mapValue]]);
 
-  const serializedOldDefaultMap = deepCopy(
-    oldDefaultMap,
+  const serializedOldMap = deepCopy(
+    oldMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedDefaultMapHasStringKey-serialize",
+    "copiedSerializedMapHasStringKey-serialize",
   );
 
   const newTable = deepCopy(
-    serializedOldDefaultMap,
+    serializedOldMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedDefaultMapHasStringKey-deserialize",
+    "copiedSerializedMapHasStringKey-deserialize",
   );
 
-  const newDefaultMap = newTable as DefaultMap<string, number>;
-  if (!newDefaultMap.has(mapKey)) {
+  const newMap = newTable as Map<string, number>;
+  if (!newMap.has(mapKey)) {
     const keyType = type(mapKey);
     error(
-      `The copied DefaultMap did not have a key of "${mapKey}" with type: ${keyType}`,
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
     );
   }
 }
 
-function copiedSerializedDefaultMapHasNumberKey() {
-  const mapKey = 123;
-  const oldDefaultMap = new DefaultMap<number, number>(456);
-  oldDefaultMap.getAndSetDefault(mapKey);
+function copiedSetHasValue() {
+  const valueToLookFor = "abc";
+  const oldSet = new Set<string>([valueToLookFor]);
 
-  const serializedOldDefaultMap = deepCopy(
-    oldDefaultMap,
-    SerializationType.SERIALIZE,
-    "copiedSerializedDefaultMapHasNumberKey-serialize",
-  );
+  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetHasValue");
+
+  if (!isTSTLSet(newSet)) {
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
+  }
+
+  const hasValue = newSet.has(valueToLookFor);
+  if (!hasValue) {
+    error(`The copied Set did not have a value of: ${valueToLookFor}`);
+  }
+}
+
+function copiedSetIsSet() {
+  const valueToLookFor = "abc";
+  const oldSet = new Set<string>([valueToLookFor]);
+
+  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
+
+  if (!isTSTLSet(newSet)) {
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
+  }
+}
+
+function copiedTableDoesNotCoerceTypes() {
+  const keyToLookFor = 123;
+  const valueToLookFor = 456;
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
+  oldTable.set(keyToLookFor, valueToLookFor);
 
   const newTable = deepCopy(
-    serializedOldDefaultMap,
-    SerializationType.DESERIALIZE,
-    "copiedSerializedDefaultMapHasNumberKey-deserialize",
+    oldTable,
+    SerializationType.NONE,
+    "copiedTableDoesNotCoerceTypes",
   );
 
-  const newDefaultMap = newTable as DefaultMap<number, number>;
-  if (!newDefaultMap.has(mapKey)) {
-    const keyType = type(mapKey);
+  const keyString = tostring(keyToLookFor);
+  const valueString = tostring(valueToLookFor);
+
+  const valueFromString = newTable.get(keyString);
+  if (valueFromString !== undefined) {
+    error(`The copied object had a string key of: ${keyString}`);
+  }
+
+  const value = newTable.get(keyToLookFor);
+  if (value === valueString) {
     error(
-      `The copied DefaultMap did not have a key of: ${mapKey} with type ${keyType}`,
+      `The copied object had a value that incorrectly matched the string of: ${valueString}`,
     );
   }
 }
+
+function copiedTableHasKeyAndValueNumber() {
+  const keyToLookFor = 123;
+  const valueToLookFor = 456;
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
+  oldTable.set(keyToLookFor, valueToLookFor);
+
+  const newTable = deepCopy(
+    oldTable,
+    SerializationType.NONE,
+    "copiedTableHasKeyAndValueNumber",
+  );
+
+  const value = newTable.get(keyToLookFor) as number | undefined;
+  if (value === undefined) {
+    error(`The copied object did not have a key of: ${keyToLookFor}`);
+  }
+
+  if (!isNumber(value)) {
+    error(`The copied object had a value type of: ${typeof value}`);
+  }
+  if (value !== valueToLookFor) {
+    error(`The copied object had a value of: ${value}`);
+  }
+}