github.com/grayzone/godcm@v0.0.0-20170704062146-8b1d61c0eb0a/dcmdata/dctagkey_test.go (about)

     1  package dcmdata
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  )
     7  
     8  func TestSetDcmTagKey(t *testing.T) {
     9  	var v DcmTagKey
    10  	v.Set(0x0001, 0x0001)
    11  	if v.group != 0x0001 {
    12  		t.Error("excepted 0x0001, got ", v.group)
    13  	}
    14  	if v.element != 0x0001 {
    15  		t.Error("excepted 0x0001, got ", v.element)
    16  	}
    17  
    18  }
    19  
    20  func TestNewDcmTagKey(t *testing.T) {
    21  	var v = NewDcmTagKey()
    22  	if v.group != 0xffff {
    23  		t.Error("excepted 0xffff, got ", v.group)
    24  	}
    25  	if v.element != 0xffff {
    26  		t.Error("excepted 0xffff, got ", v.element)
    27  	}
    28  }
    29  
    30  func TestHasValidGroup(t *testing.T) {
    31  	cases := []struct {
    32  		in   DcmTagKey
    33  		want bool
    34  	}{
    35  		{*NewDcmTagKey(), false},
    36  		{DcmTagKey{0x0001, 0x0001}, false},
    37  		{DcmTagKey{0x0003, 0x0001}, false},
    38  		{DcmTagKey{0x0005, 0x0001}, false},
    39  		{DcmTagKey{0x0007, 0x0001}, false},
    40  		{DcmTagKey{0x0009, 0x0001}, true},
    41  	}
    42  	for _, c := range cases {
    43  		got := c.in.HasValidGroup()
    44  		if got != c.want {
    45  			t.Errorf("%v HasValidGroup(), want %v got %v", c.in, c.want, got)
    46  		}
    47  	}
    48  }
    49  
    50  func BenchmarkHasValidGroup(b *testing.B) {
    51  	for i := 0x0000; i <= 0xFFFF; i++ {
    52  		var v DcmTagKey
    53  		v.group = uint16(i)
    54  		switch v.group {
    55  		case 1, 3, 5, 7, 0xFFFF:
    56  			if v.HasValidGroup() != false {
    57  				b.Error(i, v, "excepted false, got ", v.HasValidGroup())
    58  			}
    59  		default:
    60  			if v.HasValidGroup() != true {
    61  				b.Error(i, v, "excepted true, got ", v.HasValidGroup())
    62  			}
    63  		}
    64  	}
    65  }
    66  
    67  func TestIsGroupLength(t *testing.T) {
    68  	cases := []struct {
    69  		in   DcmTagKey
    70  		want bool
    71  	}{
    72  		{*NewDcmTagKey(), false},
    73  		{DcmTagKey{0x0001, 0x0001}, false},
    74  		{DcmTagKey{0x0001, 0x0000}, false},
    75  		{DcmTagKey{0x0003, 0x0001}, false},
    76  		{DcmTagKey{0x0003, 0x0000}, false},
    77  		{DcmTagKey{0x0005, 0x0001}, false},
    78  		{DcmTagKey{0x0005, 0x0000}, false},
    79  		{DcmTagKey{0x0007, 0x0001}, false},
    80  		{DcmTagKey{0x0007, 0x0000}, false},
    81  		{DcmTagKey{0x0009, 0x0001}, false},
    82  		{DcmTagKey{0x0009, 0x0000}, true},
    83  	}
    84  	for _, c := range cases {
    85  		got := c.in.IsGroupLength()
    86  		if got != c.want {
    87  			t.Errorf("%v IsGroupLength(), want %v got %v", c.in, c.want, got)
    88  		}
    89  	}
    90  
    91  }
    92  
    93  func BenchmarkIsGroupLength(b *testing.B) {
    94  	for i := 0x0000; i <= 0xFFFF; i++ {
    95  		for j := 0x0000; j <= 0xFFFF; j++ {
    96  			var v DcmTagKey
    97  			v.group = uint16(i)
    98  			v.element = uint16(j)
    99  			if j == 0x0000 {
   100  				switch v.group {
   101  				case 1, 3, 5, 7, 0xFFFF:
   102  					if v.IsGroupLength() != false {
   103  						b.Error(i, v, "excepted false, got ", v.IsGroupLength())
   104  					}
   105  				default:
   106  					if v.IsGroupLength() != true {
   107  						b.Error(i, v, "excepted true, got ", v.IsGroupLength())
   108  					}
   109  				}
   110  			} else {
   111  				switch v.group {
   112  				case 1, 3, 5, 7, 0xFFFF:
   113  					if v.IsGroupLength() != false {
   114  						b.Error(i, v, "excepted false, got ", v.IsGroupLength())
   115  					}
   116  				default:
   117  					if v.IsGroupLength() != false {
   118  						b.Error(i, v, "excepted false, got ", v.IsGroupLength())
   119  					}
   120  				}
   121  
   122  			}
   123  
   124  		}
   125  	}
   126  }
   127  
   128  func TestIsPrivate(t *testing.T) {
   129  	cases := []struct {
   130  		in   DcmTagKey
   131  		want bool
   132  	}{
   133  		{*NewDcmTagKey(), false},
   134  		{DcmTagKey{0x0001, 0x0001}, false},
   135  		{DcmTagKey{0x0002, 0x0001}, false},
   136  		{DcmTagKey{0x0003, 0x0001}, false},
   137  		{DcmTagKey{0x0004, 0x0001}, false},
   138  		{DcmTagKey{0x0005, 0x0001}, false},
   139  		{DcmTagKey{0x0006, 0x0001}, false},
   140  		{DcmTagKey{0x0007, 0x0001}, false},
   141  		{DcmTagKey{0x0008, 0x0001}, false},
   142  		{DcmTagKey{0x0009, 0x0001}, true},
   143  	}
   144  	for _, c := range cases {
   145  		got := c.in.IsPrivate()
   146  		if got != c.want {
   147  			t.Errorf("%v IsPrivate(), want %v got %v", c.in, c.want, got)
   148  		}
   149  	}
   150  
   151  }
   152  
   153  func BenchmarkIsPrivate(b *testing.B) {
   154  	for i := 0x0000; i <= 0xFFFF; i++ {
   155  		var v DcmTagKey
   156  		v.group = uint16(i)
   157  		switch v.group {
   158  		case 1, 3, 5, 7, 0xFFFF:
   159  			if v.IsPrivate() != false {
   160  				b.Error(i, v, "excepted false, got ", v.IsPrivate())
   161  			}
   162  		default:
   163  			if (v.group & 1) != 0 {
   164  				if v.IsPrivate() != true {
   165  					b.Error(i, v, "excepted true, got ", v.IsPrivate())
   166  				}
   167  
   168  			} else {
   169  				if v.IsPrivate() != false {
   170  					b.Error(i, v, "excepted false, got ", v.IsPrivate())
   171  				}
   172  
   173  			}
   174  		}
   175  	}
   176  }
   177  
   178  func TestIsPrivateReservation(t *testing.T) {
   179  	cases := []struct {
   180  		in   DcmTagKey
   181  		want bool
   182  	}{
   183  		{*NewDcmTagKey(), false},
   184  		{DcmTagKey{0x0001, 0x0001}, false},
   185  		{DcmTagKey{0x0002, 0x0001}, false},
   186  		{DcmTagKey{0x0003, 0x0001}, false},
   187  		{DcmTagKey{0x0004, 0x0001}, false},
   188  		{DcmTagKey{0x0005, 0x0001}, false},
   189  		{DcmTagKey{0x0006, 0x0001}, false},
   190  		{DcmTagKey{0x0007, 0x0001}, false},
   191  		{DcmTagKey{0x0008, 0x0001}, false},
   192  		{DcmTagKey{0x0009, 0x0001}, false},
   193  		{DcmTagKey{0x0009, 0x0011}, true},
   194  	}
   195  	for _, c := range cases {
   196  		got := c.in.IsPrivateReservation()
   197  		if got != c.want {
   198  			t.Errorf("%v IsPrivateReservation(), want %v got %v", c.in, c.want, got)
   199  		}
   200  	}
   201  
   202  }
   203  
   204  func BenchmarkIsPrivateReservation(b *testing.B) {
   205  	for i := 0x0000; i <= 0xFFFF; i++ {
   206  		for j := 0x0000; j <= 0xFFFF; j++ {
   207  			v := DcmTagKey{uint16(i), uint16(j)}
   208  			if v.element >= 0x0010 && v.element <= 0x00FF {
   209  				switch v.group {
   210  				case 1, 3, 5, 7, 0xFFFF:
   211  					if v.IsPrivateReservation() != false {
   212  						b.Error(i, v, "excepted false, got ", v.IsPrivateReservation())
   213  					}
   214  				default:
   215  					if (v.group & 1) != 0 {
   216  						if v.IsPrivateReservation() != true {
   217  							b.Error(i, v, "excepted true, got ", v.IsPrivateReservation())
   218  						}
   219  
   220  					} else {
   221  						if v.IsPrivateReservation() != false {
   222  							b.Error(i, v, "excepted false, got ", v.IsPrivateReservation())
   223  						}
   224  
   225  					}
   226  				}
   227  			} else {
   228  				switch v.group {
   229  				case 1, 3, 5, 7, 0xFFFF:
   230  					if v.IsPrivateReservation() != false {
   231  						b.Error(i, v, "excepted false, got ", v.IsPrivateReservation())
   232  					}
   233  				default:
   234  					if (v.group & 1) != 0 {
   235  						if v.IsPrivateReservation() != false {
   236  							b.Error(i, v, "excepted false, got ", v.IsPrivateReservation())
   237  						}
   238  
   239  					} else {
   240  						if v.IsPrivateReservation() != false {
   241  							b.Error(i, v, "excepted false, got ", v.IsPrivateReservation())
   242  						}
   243  
   244  					}
   245  				}
   246  
   247  			}
   248  
   249  		}
   250  	}
   251  
   252  }
   253  
   254  func TestHash(t *testing.T) {
   255  	v := DcmTagKey{0x0002, 0x0002}
   256  	if v.Hash() != 131074 {
   257  		t.Error("excepted 131074, got ", v.Hash())
   258  	}
   259  }
   260  
   261  func TestToString(t *testing.T) {
   262  	v := NewDcmTagKey()
   263  	if v.ToString() != "(????,????)" {
   264  		t.Error("excepted (????,????), got ", v.ToString())
   265  	}
   266  	v.group = 0x001F
   267  	v.element = 0x002F
   268  	if strings.ToUpper(v.ToString()) != "(001F,002F)" {
   269  		t.Error("excepted (001F,002F), got ", v.ToString())
   270  	}
   271  }
   272  
   273  func TestIsSignableTag(t *testing.T) {
   274  	cases := []struct {
   275  		in   DcmTagKey
   276  		want bool
   277  	}{
   278  		{*NewDcmTagKey(), true},
   279  		{DcmTagKey{0x0001, 0x0000}, false},
   280  		{DcmTagKey{0x0001, 0x0001}, false},
   281  		{DcmTagKey{0x0002, 0x0001}, false},
   282  		{DcmTagKey{0x0003, 0x0001}, false},
   283  		{DcmTagKey{0x0004, 0x0001}, false},
   284  		{DcmTagKey{0x0005, 0x0001}, false},
   285  		{DcmTagKey{0x0006, 0x0001}, false},
   286  		{DcmTagKey{0x0007, 0x0001}, false},
   287  		{DcmTagKey{0x0008, 0x0001}, false},
   288  		{DcmTagKey{0x0009, 0x0001}, true},
   289  		{DcmTagKey{0x0009, 0x0011}, true},
   290  		{DcmTagKey{0xFFFA, 0x0011}, false},
   291  		{DcmTagKey{0x4ffe, 0x0011}, true},
   292  		{DcmTagKey{0x4ffe, 0x0001}, false},
   293  		{DcmTagKey{0xfffc, 0xfffc}, false},
   294  		{DcmTagKey{0xfffc, 0x0001}, true},
   295  		{DcmTagKey{0xFFFe, 0xe00d}, false},
   296  		{DcmTagKey{0xFFFe, 0xe0dd}, false},
   297  		{DcmTagKey{0xFFFe, 0x0001}, true},
   298  	}
   299  	for _, c := range cases {
   300  		got := c.in.IsSignableTag()
   301  		if got != c.want {
   302  			t.Errorf("%v IsSignableTag(), want %v got %v", c.in, c.want, got)
   303  		}
   304  	}
   305  }
   306  
   307  func BenchmarkIsSignableTag(b *testing.B) {
   308  	for i := 0x0000; i <= 0xFFFF; i++ {
   309  		for j := 0x0000; j <= 0xFFFF; j++ {
   310  			v := DcmTagKey{uint16(i), uint16(j)}
   311  
   312  			if v.element == 0x0000 {
   313  				if v.IsSignableTag() != false {
   314  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   315  				}
   316  			} else if (v.group == 0x0008) && (v.element == 0x0001) {
   317  				if v.IsSignableTag() != false {
   318  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   319  				}
   320  			} else if v.group < 0x0008 {
   321  				if v.IsSignableTag() != false {
   322  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   323  				}
   324  			} else if v.group == 0xFFFA {
   325  				if v.IsSignableTag() != false {
   326  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   327  				}
   328  			} else if (v.group == 0x4FFE) && (v.element == 0x0001) {
   329  				if v.IsSignableTag() != false {
   330  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   331  				}
   332  			} else if (v.group == 0xFFFC) && (v.element == 0xFFFC) {
   333  				if v.IsSignableTag() != false {
   334  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   335  				}
   336  			} else if (v.group == 0xFFFE) && ((v.element == 0xE00D) || (v.element == 0xE0DD)) {
   337  				if v.IsSignableTag() != false {
   338  					b.Error(v, "excepted false, got ", v.IsSignableTag())
   339  				}
   340  			} else {
   341  				if v.IsSignableTag() != true {
   342  					b.Error(v, "excepted true, got ", v.IsSignableTag())
   343  				}
   344  			}
   345  		}
   346  	}
   347  }
   348  
   349  func TestEqual(t *testing.T) {
   350  	cases := []struct {
   351  		base DcmTagKey
   352  		in   DcmTagKey
   353  		want bool
   354  	}{
   355  		{DcmTagKey{0x0010, 0x001F}, DcmTagKey{0x0010, 0x001F}, true},
   356  		{DcmTagKey{0xFFFF, 0x001F}, DcmTagKey{0xFFFF, 0x001F}, true},
   357  		{DcmTagKey{0xFFFF, 0x001F}, DcmTagKey{0xFFFF, 0x001F}, true},
   358  		{DcmTagKey{0xFFFF, 0x001F}, DcmTagKey{0xFFFF, 0x001E}, false},
   359  	}
   360  	for _, c := range cases {
   361  		got := c.base.Equal(c.in)
   362  		if got != c.want {
   363  			t.Errorf("%s Equal(%s)== %v, want %v ", c.base.ToString(), c.in.ToString(), got, c.want)
   364  		}
   365  	}
   366  }