summaryrefslogtreecommitdiffstats
path: root/src/ml/dlib/dlib/test/array.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/ml/dlib/dlib/test/array.cpp')
-rw-r--r--src/ml/dlib/dlib/test/array.cpp669
1 files changed, 669 insertions, 0 deletions
diff --git a/src/ml/dlib/dlib/test/array.cpp b/src/ml/dlib/dlib/test/array.cpp
new file mode 100644
index 000000000..55ba1a724
--- /dev/null
+++ b/src/ml/dlib/dlib/test/array.cpp
@@ -0,0 +1,669 @@
+// Copyright (C) 2005 Davis E. King (davis@dlib.net)
+// License: Boost Software License See LICENSE.txt for the full license.
+
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+#include <dlib/interfaces/enumerable.h>
+#include <dlib/array.h>
+#include <dlib/rand.h>
+
+
+#include "tester.h"
+
+namespace
+{
+ using namespace test;
+ using namespace dlib;
+ using namespace std;
+
+ using dlib::array;
+
+ logger dlog("test.array");
+
+ template <
+ typename array
+ >
+ void array_expand_test (
+ )
+ /*!
+ requires
+ - array is an implementation of array/array_sort_abstract.h
+ array is instantiated with unsigned long
+ ensures
+ - runs tests on array for compliance with the specs
+ !*/
+ {
+ dlib::rand rnd;
+
+ DLIB_TEST(dlib::is_array<array>::value == true);
+
+ array a1, a2;
+
+ {
+ array a4(4);
+ DLIB_TEST(a4.size() == 4);
+ }
+
+ {
+ array a1, a2;
+
+ for (int k = 1; k < 100000; k += 1000)
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ a1.clear();
+ a1.set_max_size(500+k);
+ a1.set_size(500+k);
+ for (unsigned long j = 0; j < a1.size(); ++j)
+ {
+ a1[j] = j;
+ DLIB_TEST(a1[j] == j);
+ }
+ }
+ }
+ }
+
+ DLIB_TEST(a1.max_size() == 0);
+ DLIB_TEST(a2.max_size() == 0);
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ swap(a1,a2);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.move_next() == false);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.size() == 0);
+
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ a1.reset();
+ a2.reset();
+
+ for (unsigned long k = 0; k < 4; ++k)
+ {
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ swap(a1,a2);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.move_next() == false);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.size() == 0);
+
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ a1.clear();
+ a2.clear();
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ swap(a1,a2);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.move_next() == false);
+ DLIB_TEST(a2.current_element_valid() == false);
+ DLIB_TEST(a2.size() == 0);
+ DLIB_TEST(a2.at_start() == false);
+ DLIB_TEST(a2.size() == 0);
+
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.move_next() == false);
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.at_start() == false);
+ DLIB_TEST(a1.size() == 0);
+
+ a1.clear();
+ a2.clear();
+
+
+
+
+ a1.set_max_size(100000);
+ a2.set_max_size(100000);
+ a1.set_size(10000);
+ DLIB_TEST(a1.size() == 10000);
+ a2.set_size(10000);
+ DLIB_TEST(a2.size() == 10000);
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ unsigned long a = static_cast<unsigned long>(rnd.get_random_32bit_number());
+ a1[i] = a;
+ a2[i] = i;
+ DLIB_TEST(a1[i] == a);
+ DLIB_TEST(a2[i] == i);
+ }
+
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next());
+ DLIB_TEST(a1.current_element_valid());
+
+ DLIB_TEST(a1.at_start() == false);
+ a1.sort();
+ DLIB_TEST(a1.at_start());
+ a2.sort();
+ DLIB_TEST(a1.size() == 10000);
+ DLIB_TEST(a2.size() == 10000);
+
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ if (i+1 < a1.size())
+ {
+ DLIB_TEST_MSG(a1[i] <= a1[i+1],
+ "a1[i]: " << a1[i] << " a1[i+1]: " << a1[i+1]
+ << " i: " << i);
+ }
+ DLIB_TEST_MSG(a2[i] == i,"i: " << i << " a2[i]: " << a2[i]);
+ }
+
+ unsigned long last = 0;
+ unsigned long count = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ ++count;
+ }
+ DLIB_TEST(count == a1.size());
+
+ last = 0;
+ count = 0;
+ while (a2.move_next())
+ {
+ DLIB_TEST(last <= a2.element());
+ last = a2.element();
+ ++count;
+ }
+ DLIB_TEST(count == a2.size());
+
+ a2.set_size(15000);
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ if (i+1 < a1.size())
+ {
+ DLIB_TEST(a1[i] <= a1[i+1]);
+ }
+ DLIB_TEST(a2[i] == i);
+ }
+
+ for (unsigned long i = 10000; i < a2.size(); ++i)
+ {
+ a2[i] = i;
+ DLIB_TEST(a2[i] == i);
+ }
+
+ for (unsigned long i = 0; i < a2.size(); ++i)
+ {
+ DLIB_TEST(a2[i] == i);
+ }
+
+ a2.reset();
+ last = 0;
+ while (a2.move_next())
+ {
+ DLIB_TEST(last <= a2.element());
+ last = a2.element();
+ }
+
+ a1.reset();
+ last = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ }
+
+ a1.sort();
+ last = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ }
+
+ swap(a2,a1);
+
+ for (unsigned long i = 0; i < 15000; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+
+
+ a1.clear();
+ DLIB_TEST(a1.max_size() == 0);
+
+
+
+
+ a1.clear();
+ a2.clear();
+
+
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a2.size() == 0);
+ a1.set_max_size(100000);
+ a2.set_max_size(100000);
+
+ a1.set_size(10000);
+ DLIB_TEST(a1.size() == 10000);
+ a2.set_size(10000);
+ DLIB_TEST(a2.size() == 10000);
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ unsigned long a = static_cast<unsigned long>(rnd.get_random_32bit_number());
+ a1[i] = a;
+ a2[i] = i;
+ DLIB_TEST(a1[i] == a);
+ DLIB_TEST(a2[i] == i);
+ }
+
+ DLIB_TEST(a1.at_start());
+ DLIB_TEST(a1.current_element_valid() == false);
+ DLIB_TEST(a1.move_next());
+ DLIB_TEST(a1.current_element_valid());
+
+ DLIB_TEST(a1.at_start() == false);
+ a1.sort();
+ DLIB_TEST(a1.at_start());
+ a2.sort();
+ DLIB_TEST(a1.size() == 10000);
+ DLIB_TEST(a2.size() == 10000);
+
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ if (i+1 < a1.size())
+ {
+ DLIB_TEST(a1[i] <= a1[i+1]);
+ }
+ DLIB_TEST(a2[i] == i);
+ }
+
+ last = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ }
+
+ last = 0;
+ while (a2.move_next())
+ {
+ DLIB_TEST(last <= a2.element());
+ last = a2.element();
+ }
+
+ a2.set_size(15000);
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ if (i+1 < a1.size())
+ {
+ DLIB_TEST(a1[i] <= a1[i+1]);
+ }
+ DLIB_TEST(a2[i] == i);
+ }
+
+ for (unsigned long i = 10000; i < a2.size(); ++i)
+ {
+ a2[i] = i;
+ DLIB_TEST(a2[i] == i);
+ }
+
+ for (unsigned long i = 0; i < a2.size(); ++i)
+ {
+ DLIB_TEST(a2[i] == i);
+ }
+
+ a2.reset();
+ last = 0;
+ while (a2.move_next())
+ {
+ DLIB_TEST(last <= a2.element());
+ last = a2.element();
+ }
+
+ a1.reset();
+ last = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ }
+
+ a1.sort();
+ last = 0;
+ while (a1.move_next())
+ {
+ DLIB_TEST(last <= a1.element());
+ last = a1.element();
+ }
+
+ swap(a2,a1);
+
+ for (unsigned long i = 0; i < 15000; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+
+
+ a1.clear();
+ DLIB_TEST(a1.max_size() == 0);
+
+ a2.clear();
+ print_spinner();
+ }
+
+
+
+ a1.set_max_size(2000000);
+ DLIB_TEST(a1.max_size() == 2000000);
+ DLIB_TEST(a1.size() == 0);
+ a1.set_size(2000000);
+ DLIB_TEST(a1.max_size() == 2000000);
+ DLIB_TEST(a1.size() == 2000000);
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ a1[i] = rnd.get_random_32bit_number();
+ }
+
+ print_spinner();
+ a1.sort();
+
+ print_spinner();
+ // serialize the state of a1, then clear a1, then
+ // load the state back into a1.
+ ostringstream sout;
+ serialize(a1,sout);
+ DLIB_TEST(a1.at_start() == true);
+ istringstream sin(sout.str());
+ a1.clear();
+ DLIB_TEST(a1.max_size() == 0);
+ deserialize(a1,sin);
+
+ DLIB_TEST(a1.size() == 2000000);
+
+ for (unsigned long i = 0; i < a1.size()-1; ++i)
+ {
+ DLIB_TEST(a1[i] <= a1[i+1]);
+ }
+
+ DLIB_TEST(a1.max_size() == 2000000);
+ DLIB_TEST(a1.size() == 2000000);
+
+
+ swap(a1,a2);
+
+ print_spinner();
+
+ DLIB_TEST(a2.size() == 2000000);
+
+ for (unsigned long i = 0; i < a2.size()-1; ++i)
+ {
+ DLIB_TEST(a2[i] <= a2[i+1]);
+ }
+
+ DLIB_TEST(a2.max_size() == 2000000);
+ DLIB_TEST(a2.size() == 2000000);
+
+ swap(a1,a2);
+
+
+ a1.clear();
+ DLIB_TEST(a1.size() == 0);
+ DLIB_TEST(a1.max_size() == 0);
+
+ a1.resize(10);
+ DLIB_TEST(a1.size() == 10);
+ DLIB_TEST(a1.max_size() == 10);
+
+ for (unsigned long i = 0; i < a1.size(); ++i)
+ {
+ a1[i] = i;
+ }
+
+ print_spinner();
+ a1.resize(100);
+ DLIB_TEST(a1.size() == 100);
+ DLIB_TEST(a1.max_size() == 100);
+
+ for (unsigned long i = 0; i < 10; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+ a1.resize(50);
+ DLIB_TEST(a1.size() == 50);
+ DLIB_TEST(a1.max_size() == 100);
+
+ for (unsigned long i = 0; i < 10; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+ a1.resize(10);
+ DLIB_TEST(a1.size() == 10);
+ DLIB_TEST(a1.max_size() == 100);
+
+ for (unsigned long i = 0; i < 10; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+ a1.resize(20);
+ DLIB_TEST(a1.size() == 20);
+ DLIB_TEST(a1.max_size() == 100);
+
+ for (unsigned long i = 0; i < 10; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+
+ a1.resize(100);
+ DLIB_TEST(a1.size() == 100);
+ DLIB_TEST(a1.max_size() == 100);
+
+ for (unsigned long i = 0; i < 10; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+
+ {
+ a1.clear();
+ DLIB_TEST(a1.size() == 0);
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ unsigned long a = i;
+ a1.push_back(a);
+ DLIB_TEST(a1.size() == i+1);
+ DLIB_TEST(a1.back() == i);
+ }
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ unsigned long a = 0;
+ a1.pop_back(a);
+ DLIB_TEST(a == 99-i);
+ }
+ }
+
+ {
+ a1.clear();
+ DLIB_TEST(a1.size() == 0);
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ unsigned long a = i;
+ a1.push_back(a);
+ DLIB_TEST(a1.size() == i+1);
+ DLIB_TEST(a1.back() == i);
+ }
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ DLIB_TEST(a1[i] == i);
+ }
+ for (unsigned long i = 0; i < 100; ++i)
+ {
+ a1.pop_back();
+ }
+ DLIB_TEST(a1.size() == 0);
+ }
+
+ }
+
+ struct stuff
+ {
+ int whatever;
+ };
+ void another_array_test()
+ {
+ array<stuff> a;
+ a.resize(5);
+ a[0].whatever = 0;
+ stuff temp;
+ temp.whatever = 99;
+ a.push_back(temp);
+ DLIB_TEST(a.size() == 6);
+ DLIB_TEST(a[5].whatever == 99);
+
+ DLIB_TEST(dlib::is_array<array<stuff> >::value == true);
+ }
+
+ void test_array_split()
+ {
+ array<int> temp(5);
+
+ for (unsigned int i = 0; i < temp.size(); ++i)
+ temp[i] = i;
+
+ array<int> b;
+
+ split_array(temp, b, 0.5);
+ DLIB_TEST(temp.size() == 2);
+ DLIB_TEST(b.size() == 3);
+
+ DLIB_TEST(temp[0] == 0);
+ DLIB_TEST(temp[1] == 1);
+ DLIB_TEST(b[0] == 2);
+ DLIB_TEST(b[1] == 3);
+ DLIB_TEST(b[2] == 4);
+ }
+
+ class array_tester : public tester
+ {
+ public:
+ array_tester (
+ ) :
+ tester ("test_array",
+ "Runs tests on the array component.")
+ {}
+
+ void perform_test (
+ )
+ {
+ print_spinner();
+ another_array_test();
+
+ // test a checking version first for good measure
+ print_spinner();
+ array_expand_test<array<unsigned long> >();
+
+ DLIB_TEST(dlib::is_array<int>::value == false);
+ test_array_split();
+ }
+ } a;
+
+
+
+
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 04:31:13 +0000