feat(sdk): std.Set tests

examples/tests/invalid/container_types.test.w

@@ -28,5 +28,16 @@ let a: Array<str> = MutArray<str>[];
 //                  ^^^^^^^^^^^^^^^ Expected type to be "Array<str>", but got "MutArray<str>" instead
 
 let mm1: MutMap<num> = { "a" => 1, "b" => 2, "c" => 3 };
+//                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Expected type to be "MutMap<num>", but got "Map<num>" instead
 let mm2 = MutMap<num> { "a" => 1, "b" => 2, "c" => 3 };
-let mm3 = mm2.copyMut();
+let mm3 = mm2.copyMut();
+//            ^^^^^^^ Unknown symbol "copyMut"
+
+
+let ss1: MutSet<str> = Set{"c"};
+//                        ^^^^^ Expected type to be "MutSet<str>", but got "Set<str>" instead
+let ss2: MutSet<num> = MutSet<num> {true};
+//                                  ^^^^ Expected type to be "num", but got "bool" instead
+let ss3 = MutSet<bool> {false, true};
+let ss4 = ss3.copyMut();
+//            ^^^^^^^ Unknown symbol "copyMut"

examples/tests/invalid/immutable_container_types.test.w

@@ -4,9 +4,30 @@ m1.set("a", "bye");
 // ^^^ Unknown symbol "set" (TODO: better error message https://github.com/winglang/wing/issues/1660)
 
 let m2: Map<str> = MutMap<str> {};
+//                 ^^^^^^^^^^^^^^ Expected type to be "Map<str>", but got "MutMap<str>" instead
 let m3 = Map<bool> { "a" => "A" };
+//                          ^^^ Expected type to be "bool", but got "str" instead
 let m4 = {"1" => 1, "2" => 2 };
 m4.set("2", 3);
+// ^^^ Unknown symbol "set"
 let m5 = m4.copy();
+//          ^^^^ Unknown symbol "copy"
 m4.delete("1");
-m4.clear();
+// ^^^^^^ Unknown symbol "delete"
+m4.clear();
+// ^^^^^ Unknown symbol "clear"
+
+
+let s1: Set<Array<num>> = MutSet<Array<num>> {[1]};
+//                        ^^^^^^^^^^^^^^^^^^^^^^^^ Expected type to be "Set<Array<num>>", but got "MutSet<Array<num>>" instead
+let s2 = Set<str> {"a", "b", "c"};
+s2.delete("a");
+// ^^^^^^ Unknown symbol "delete"
+s2.add("d");
+// ^^^ Unknown symbol "add"
+let s3 = s2.copy();
+//          ^^^^ Unknown symbol "copy"
+s2.clear();
+// ^^^^^ Unknown symbol "clear"
+let s4: Set<bool> = {[3]};
+//                  ^^^^^ Expected type to be "Set<bool>", but got "Set<Array<num>>" instead

examples/tests/sdk_tests/std/map.test.w

@@ -1,6 +1,3 @@
-//-----------------------------------------------------------------------------
-// TODO: https://github.com/winglang/wing/issues/2785
-
 //-----------------------------------------------------------------------------
 // keys()
 let m = { "hello" => 123, "world" => 99 };
@@ -16,6 +13,7 @@ assert(mvalues.length == 2);
 assert(mvalues.at(0) == 123);
 assert(mvalues.at(1) == 99);
 
+
 // container types are equal regardless of the mutability if they have the same
 // content but in all scenraios the type is specified for better readability
 

examples/tests/sdk_tests/std/set.test.w

@@ -1,6 +1,3 @@
-//-----------------------------------------------------------------------------
-// TODO: https://github.com/winglang/wing/issues/2785
-
 //-----------------------------------------------------------------------------
 // toArray()
 let mySet = Set<num> {1, 2, 3};
@@ -18,4 +15,191 @@ assert(myArrayFromMutSet.at(1) == "b");
 assert(myArrayFromMutSet.at(2) == "c");
 assert(myArrayFromMutSet.length == myMutSet.size);
 assert(myArrayFromMutSet.length == 3);
-//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+// container types are equal regardless of the mutability if they have the same
+// content but in all scenraios the type is specified for better readability
+
+assert(Set<num>{1, 2} == MutSet<num>{1, 2});
+assert(Set<bool>{true, false} == MutSet<bool>{false, true});
+
+test "equality"{
+    assert(Set<num>{1, 2} == MutSet<num>{1, 2});
+    assert(Set<bool>{true, false} == MutSet<bool>{false, true});
+}
+
+
+let openings = MutSet<str> {"A Cruel Angel's Thesis", "Lilium", "Unravel", "TOP"};
+let immutOpenings: Set<str> = openings.copy();
+assert(immutOpenings.copyMut() == openings);
+openings.add("Abnormalize");
+assert(openings.has("Abnormalize"));
+openings.delete("TOP");
+assert(openings.has("TOP") == false);
+openings.clear();
+assert(openings.size == 0);
+
+test "mutability" {
+    let openings = MutSet<str> {"A Cruel Angel's Thesis", "Lilium", "Unravel", "TOP"};
+    let immutOpenings: Set<str> = openings.copy();
+    assert(immutOpenings.copyMut() == openings);
+    openings.add("Abnormalize");
+    assert(openings.has("Abnormalize"));
+    openings.delete("TOP");
+    assert(openings.has("TOP") == false);
+    openings.clear();
+    assert(openings.size == 0);
+}
+
+
+let maleVA = {"Kenjiro Tsuda", "Akira Ishida", "Yoshitsugu Matsuoka"};
+assert(maleVA.size == 3);
+
+let femaleVA = MutSet<str>{"Saori Hayami", "Miyuki Sawashiro"};
+assert(femaleVA.size == 2);
+femaleVA.add("Maaya Sakamoto");
+assert(femaleVA.size == 3);
+femaleVA.clear();
+assert(femaleVA.size == 0);
+
+test "size()" {
+    let maleVA = {"Kenjiro Tsuda", "Akira Ishida", "Yoshitsugu Matsuoka"};
+    assert(maleVA.size == 3);
+
+    let femaleVA = MutSet<str>{"Saori Hayami", "Miyuki Sawashiro"};
+    assert(femaleVA.size == 2);
+    femaleVA.add("Maaya Sakamoto");
+    assert(femaleVA.size == 3);
+    femaleVA.clear();
+    assert(femaleVA.size == 0);
+}
+
+
+let genre = {"isekai", "mecha", "cyberpunk"};
+assert(genre.has("drama") == false);
+assert(genre.has("mecha"));
+
+let mutGenre = MutSet<str> {"rom-com", "sports", "sci-fi"};
+assert(mutGenre.has("psychological") == false);
+assert(mutGenre.has("rom-com"));
+mutGenre.delete("rom-com");
+mutGenre.add("psychological");
+assert(mutGenre.has("psychological"));
+assert(mutGenre.has("rom-com") == false);
+
+test "has()" {
+    let genre = {"isekai", "mecha", "cyberpunk"};
+    assert(genre.has("drama") == false);
+    assert(genre.has("mecha"));
+
+    let mutGenre = MutSet<str> {"rom-com", "sports", "sci-fi"};
+    assert(mutGenre.has("psychological") == false);
+    assert(mutGenre.has("rom-com"));
+    mutGenre.delete("rom-com");
+    mutGenre.add("psychological");
+    assert(mutGenre.has("psychological"));
+    assert(mutGenre.has("rom-com") == false);
+}
+
+
+let endings = Set<bool>{};
+assert(endings.toArray() == Array<bool>[]);
+let strEndings = {"Somewhere, Faraway, Everyone is Listening to a Ballad"};
+assert(strEndings.toArray() == ["Somewhere, Faraway, Everyone is Listening to a Ballad"]);
+let copyEndings = endings.copyMut();
+assert(copyEndings.toArray() == endings.toArray());
+
+let mutEndings = MutSet<Array<str>> {["Fly Me To The Moon", "Slump"], ["Heikousen"]};
+assert(mutEndings.toArray() == [["Fly Me To The Moon", "Slump"], ["Heikousen"]]);
+mutEndings.add(["Wagamama"]);
+assert(mutEndings.toArray() == [["Fly Me To The Moon", "Slump"], ["Heikousen"], ["Wagamama"]]);
+let immutEndings = mutEndings.copy();
+assert(immutEndings.toArray() == mutEndings.toArray());
+
+test "toArray()" {
+    let endings = Set<bool>{};
+    assert(endings.toArray() == Array<bool>[]);
+    let strEndings = {"Somewhere, Faraway, Everyone is Listening to a Ballad"};
+    assert(strEndings.toArray() == ["Somewhere, Faraway, Everyone is Listening to a Ballad"]);
+    let copyEndings = endings.copyMut();
+    assert(copyEndings.toArray() == endings.toArray());
+
+    let mutEndings = MutSet<Array<str>> {["Fly Me To The Moon", "Slump"], ["Heikousen"]};
+    assert(mutEndings.toArray() == [["Fly Me To The Moon", "Slump"], ["Heikousen"]]);
+    mutEndings.add(["Wagamama"]);
+    assert(mutEndings.toArray() == [["Fly Me To The Moon", "Slump"], ["Heikousen"], ["Wagamama"]]);
+    let immutEndings = mutEndings.copy();
+    assert(immutEndings.toArray() == mutEndings.toArray());
+}
+
+
+let talkingQuirks = {"dattebane", "battebayo", "dattebasa"};
+assert(talkingQuirks.copyMut() == MutSet<str> {"dattebane", "battebayo", "dattebasa"});
+
+test "copyMut()" {
+    let talkingQuirks = {"dattebane", "battebayo", "dattebasa"};
+assert(talkingQuirks.copyMut() == MutSet<str> {"dattebane", "battebayo", "dattebasa"});
+}
+
+
+let evaRebuild = MutSet<num> {1.11, 2.22, 3.33};
+evaRebuild.add(3.0+1.0);
+assert(evaRebuild.has(3.0+1.0));
+assert(evaRebuild == MutSet<num>{1.11, 2.22, 3.33, 3.0+1.0});
+
+test "add()" {
+    let evaRebuild = MutSet<num> {1.11, 2.22, 3.33};
+    evaRebuild.add(3.0+1.0);
+    assert(evaRebuild.has(3.0+1.0));
+    assert(evaRebuild == MutSet<num>{1.11, 2.22, 3.33, 3.0+1.0});
+}
+
+
+let studios = MutSet<str> {"Gainax", "Ghibli", "Production I.G.", "Shaft"};
+assert(studios.delete("Gainax"));
+assert(studios.has("Gainax") == false);
+assert(studios.delete("Sunrise") == false);
+assert(studios.size == 3);
+
+test "delete()" {
+    let studios = MutSet<str> {"Gainax", "Ghibli", "Production I.G.", "Shaft"};
+    assert(studios.delete("Gainax"));
+    assert(studios.has("Gainax") == false);
+    assert(studios.delete("Sunrise") == false);
+    assert(studios.size == 3);
+}
+
+
+let demographics = MutSet<str> {"shounen", "shoujo", "josei", "seinen"};
+demographics.clear();
+assert(demographics.size == 0);
+demographics.add("kodomo");
+demographics.clear();
+assert(demographics.has("kodomo") == false);
+
+test "clear()" {
+    let demographics = MutSet<str> {"shounen", "shoujo", "josei", "seinen"};
+    demographics.clear();
+    assert(demographics.size == 0);
+    demographics.add("kodomo");
+    demographics.clear();
+    assert(demographics.has("kodomo") == false);
+}
+
+
+let acronyms = MutSet<Map<str>> {{"SEL" => "Serial Experiments Lain", "NGE" => "Neon Genesis Evangelion"}};
+let copyAcronyms = acronyms.copy();
+assert(copyAcronyms == {{"SEL" => "Serial Experiments Lain", "NGE" => "Neon Genesis Evangelion"}});
+acronyms.add({"DomeKano" => "Domestic na Kanojo"});
+let copyAcronymsNew = acronyms.copy().copyMut();
+assert(copyAcronymsNew == acronyms);
+
+test "copy()" {
+    let acronyms = MutSet<Map<str>> {{"SEL" => "Serial Experiments Lain", "NGE" => "Neon Genesis Evangelion"}};
+    let copyAcronyms = acronyms.copy();
+    assert(copyAcronyms == {{"SEL" => "Serial Experiments Lain", "NGE" => "Neon Genesis Evangelion"}});
+    acronyms.add({"DomeKano" => "Domestic na Kanojo"});
+    let copyAcronymsNew = acronyms.copy().copyMut();
+    assert(copyAcronymsNew == acronyms);
+}