Hand-Writing-Recognition-Project/tree-image-directed-test.cc at master · hp298/Hand-Writing-Recognition-Project · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
//========================================================================
// tree-image-directed-test.cc
//========================================================================
// This file contains directed tests for Tree<Image>

#include "Image.h"
#include "Tree.h"
#include "tree-directed-test.h"
#include "utst.h"

//------------------------------------------------------------------------
// Object Creation Functions
//------------------------------------------------------------------------
// All of the generic test functions are templated by an "object
// creation" function which should take as a parameter an integer and
// return a newly created object. For an Image, the object creation
// function can set each pixel value based on the given integer.

Image mk_1x1( int value )
{
  int data[] = { value };
  Vector<int> vec( data, 1 );
  return Image( vec, 1, 1 );
}

Image mk_3x3( int value )
{
  int data[] =
    { value-2, value-1, value-2,
      value-1, value,   value-1,
      value-2, value-1, value-2 };

  Vector<int> vec( data, 9 );
  return Image( vec, 3, 3 );
}

//------------------------------------------------------------------------
// main
//------------------------------------------------------------------------

int main( int argc, char** argv )
{
  __n = ( argc == 1 ) ? 0 : atoi( argv[1] );

  printf("\n Testing with 1x1 images \n");

  if ( !__n || ( __n ==  1 ) ) test_case_simple_add<Image>(1,&mk_1x1);
  if ( !__n || ( __n ==  2 ) ) test_case_duplicate_add<Image>(2,&mk_1x1);
  if ( !__n || ( __n ==  3 ) ) test_case_construct_empty<Image>(3,&mk_1x1);
  if ( !__n || ( __n ==  4 ) ) test_case_find_simple<Image>(4,&mk_1x1);
  if ( !__n || ( __n ==  5 ) ) test_case_find_empty<Image>(5,&mk_1x1);
  if ( !__n || ( __n ==  6 ) ) test_case_find_closest_balanced_largeK<Image>(6,&mk_1x1);
  if ( !__n || ( __n ==  7 ) ) test_case_find_closest_balanced_smallK<Image>(7,&mk_1x1);
  if ( !__n || ( __n ==  8 ) ) test_case_find_closest_unbalanced_largeK<Image>(8,&mk_1x1);
  if ( !__n || ( __n ==  9 ) ) test_case_find_closest_unbalanced_smallK<Image>(9,&mk_1x1);
  if ( !__n || ( __n == 10 ) ) test_case_copy_v1<Image>(10,&mk_1x1);
  if ( !__n || ( __n == 11 ) ) test_case_copy_v2<Image>(11,&mk_1x1);
  if ( !__n || ( __n == 12 ) ) test_case_copy_empty<Image>(12,&mk_1x1);
  if ( !__n || ( __n == 13 ) ) test_case_assignment<Image>(13,&mk_1x1);
  if ( !__n || ( __n == 14 ) ) test_case_assignment_to_empty<Image>(14,&mk_1x1);
  if ( !__n || ( __n == 15 ) ) test_case_assignment_from_empty<Image>(15,&mk_1x1);
  if ( !__n || ( __n == 16 ) ) test_case_assignment_empty<Image>(16,&mk_1x1);
  if ( !__n || ( __n == 17 ) ) test_case_assignment_self<Image>(17,&mk_1x1);
  if ( !__n || ( __n == 18 ) ) test_case_general<Image>(18,&mk_1x1);

  printf("\n\n Testing with 3x3 images \n");

  if ( !__n || ( __n == 19 ) ) test_case_simple_add<Image>(19,&mk_3x3);
  if ( !__n || ( __n == 20 ) ) test_case_duplicate_add<Image>(20,&mk_3x3);
  if ( !__n || ( __n == 21 ) ) test_case_construct_empty<Image>(21,&mk_3x3);
  if ( !__n || ( __n == 22 ) ) test_case_find_simple<Image>(22,&mk_3x3);
  if ( !__n || ( __n == 23 ) ) test_case_find_empty<Image>(23,&mk_3x3);
  if ( !__n || ( __n == 24 ) ) test_case_find_closest_balanced_largeK<Image>(24,&mk_1x1);
  if ( !__n || ( __n == 25 ) ) test_case_find_closest_balanced_smallK<Image>(25,&mk_1x1);
  if ( !__n || ( __n == 26 ) ) test_case_find_closest_unbalanced_largeK<Image>(26,&mk_1x1);
  if ( !__n || ( __n == 27 ) ) test_case_find_closest_unbalanced_smallK<Image>(27,&mk_1x1);
  if ( !__n || ( __n == 28 ) ) test_case_copy_v1<Image>(28,&mk_3x3);
  if ( !__n || ( __n == 29 ) ) test_case_copy_v2<Image>(29,&mk_3x3);
  if ( !__n || ( __n == 30 ) ) test_case_copy_empty<Image>(30,&mk_3x3);
  if ( !__n || ( __n == 31 ) ) test_case_assignment<Image>(31,&mk_3x3);
  if ( !__n || ( __n == 32 ) ) test_case_assignment_to_empty<Image>(32,&mk_3x3);
  if ( !__n || ( __n == 33 ) ) test_case_assignment_from_empty<Image>(33,&mk_3x3);
  if ( !__n || ( __n == 34 ) ) test_case_assignment_empty<Image>(34,&mk_3x3);
  if ( !__n || ( __n == 35 ) ) test_case_assignment_self<Image>(35,&mk_3x3);
  if ( !__n || ( __n == 36 ) ) test_case_general<Image>(36,&mk_3x3);

  printf("\n");
  return 0;
}