#include <iostream>
#include <map>
#include <cassert>
#include <vector>
#include <set>

#define Assert(ex) assert(test_name.c_str() && (ex))
#define TEST(title) test_name = (title);

#include "func.h"

char RndLetter() {
return (rand() % 26) + 'a';
}

int RndInt(int l, int r) {
return (rand() % (r - l + 1)) + l;
}

int main() {
int test; std::cin >> test;
std::string test_name;
srand(test);

TEST("not serializable") {
std::set<int> not_working;
not_working.insert(1);
not_working.insert(2);
not_working.insert(2);
Assert(Serialize(not_working) == "");
}

TEST("string serialize") {
std::string name = "Dasha";
Assert(Serialize(name) == "\"Dasha\"");
}

std::vector<std::string> names;
TEST("random strings") {
int q = (test == 0 ? 10 : 100);
for (size_t i = 0; i < q; ++i) {
int size = (rand() % 7) + 5;
std::string name(size, '\0');
for (size_t j = 0; j < size; ++j) {
name[j] = RndLetter();
}
Assert(Serialize(name) == "\"" + name + "\"");
names.push_back(name);
}
}

TEST("vector check") {
std::vector<int> numbers = {1, 2, 3};
Assert(Serialize(numbers) == "[1,2,3]");

std::vector<std::string> strings = {"a", "bb", "ccc"};
Assert(Serialize(strings) == "[\"a\",\"bb\",\"ccc\"]");

std::vector<int> empty;
Assert(Serialize(empty) == "[]");
}

TEST("map check") {
std::map<int, std::string> test_map = {{1, "one"}, {2, "two"}};
Assert(Serialize(test_map) == "{1:\"one\",2:\"two\"}");

std::map<std::string, int> string_keys = {{"a", 1}, {"b", 2}};
Assert(Serialize(string_keys) == "{\"a\":1,\"b\":2}");

std::map<int, int> empty_map;
Assert(Serialize(empty_map) == "{}");
}

TEST("nested structures") {
std::vector<std::map<int, std::string>> nested = {
{{1, "a"}, {2, "b"}},
{{3, "c"}, {4, "d"}}
};
// std::cout << Serialize(nested) << '\n';
Assert(Serialize(nested) == "[{1:\"a\",2:\"b\"},{3:\"c\",4:\"d\"}]");

std::map<std::string, std::vector<int>> map_with_vectors = {
{"odds", {1, 3, 5}},
{"evens", {2, 4, 6}}
};
Assert(Serialize(map_with_vectors) == "{\"evens\":[2,4,6],\"odds\":[1,3,5]}");
}

TEST("int serialize") {
Assert(Serialize(42) == "42");
Assert(Serialize(-10) == "-10");
Assert(Serialize(0) == "0");
}

TEST("empty collections") {
std::vector<int> empty_vec;
std::map<int, int> empty_map;
std::vector<std::map<int, int>> empty_nested;

Assert(Serialize(empty_vec) == "[]");
Assert(Serialize(empty_map) == "{}");
Assert(Serialize(empty_nested) == "[]");
}

TEST("single element collections") {
std::vector<int> single = {42};
std::map<int, std::string> single_map = {{1, "one"}};

Assert(Serialize(single) == "[42]");
Assert(Serialize(single_map) == "{1:\"one\"}");
}

std::cout << "All tests passed!" << std::endl;
return 0;
}