git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**
   2  * This document is a part of the source code and related artifacts
   3  * for CollectionSpace, an open source collections management system
   4  * for museums and related institutions:
   5  *
   6  * http://www.collectionspace.org
   7  * http://wiki.collectionspace.org
   8  *
   9  * Copyright © 2009 Regents of the University of California
  10  *
  11  * Licensed under the Educational Community License (ECL), Version 2.0.
  12  * You may not use this file except in compliance with this License.
  13  *
  14  * You may obtain a copy of the ECL 2.0 License at
  15  * https://source.collectionspace.org/collection-space/LICENSE.txt
  16  *
  17  * Unless required by applicable law or agreed to in writing, software
  18  * distributed under the License is distributed on an "AS IS" BASIS,
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  * See the License for the specific language governing permissions and
  21  * limitations under the License.
  22  */
  23
  24 package org.collectionspace.services.id.test;
  25
  26 import org.collectionspace.services.id.AlphabeticIDGeneratorPart;
  27 import org.collectionspace.services.id.SequenceIDGeneratorPart;
  28
  29 import static org.junit.Assert.fail;
  30 import junit.framework.TestCase;
  31
  32 /**
  33  * AlphabeticIDGeneratorPartTest
  34  *
  35  * Test class for AlphabeticIDGeneratorPart.
  36  *
  37  * $LastChangedRevision$
  38  * $LastChangedDate$
  39  */
  40 public class AlphabeticIDGeneratorPartTest extends TestCase {
  41
  42         SequenceIDGeneratorPart part;
  43
  44         public void testNextIDLowercase() {
  45
  46                 part = new AlphabeticIDGeneratorPart("a");
  47                 assertEquals("a", part.newID());
  48                 assertEquals("b", part.newID());
  49                 assertEquals("c", part.newID());
  50
  51                 part = new AlphabeticIDGeneratorPart("x");
  52                 assertEquals("x", part.newID());
  53                 assertEquals("y", part.newID());
  54                 assertEquals("z", part.newID());
  55
  56 }
  57
  58         public void testnewIDLowercase2Chars() {
  59
  60                 part = new AlphabeticIDGeneratorPart("aa");
  61                 assertEquals("aa", part.newID());
  62                 assertEquals("ab", part.newID());
  63                 assertEquals("ac", part.newID());
  64
  65                 part = new AlphabeticIDGeneratorPart("zx");
  66                 assertEquals("zx", part.newID());
  67                 assertEquals("zy", part.newID());
  68                 assertEquals("zz", part.newID());
  69
  70         }
  71
  72         public void testnewIDLowercase2CharsRolloverFirst() {
  73
  74                 part = new AlphabeticIDGeneratorPart("ay");
  75                 assertEquals("ay", part.newID());
  76                 assertEquals("az", part.newID());
  77                 assertEquals("ba", part.newID());
  78                 assertEquals("bb", part.newID());
  79
  80     }
  81
  82         public void testnewIDUppercase() {
  83
  84                 part = new AlphabeticIDGeneratorPart("A", "Z", "A");
  85                 assertEquals("A", part.newID());
  86                 assertEquals("B", part.newID());
  87                 assertEquals("C", part.newID());
  88
  89                 part = new AlphabeticIDGeneratorPart("A", "Z", "X");
  90                 assertEquals("X", part.newID());
  91                 assertEquals("Y", part.newID());
  92                 assertEquals("Z", part.newID());
  93
  94     }
  95
  96         public void testnewIDUppercase2Chars() {
  97
  98                 part = new AlphabeticIDGeneratorPart("A", "Z", "AA");
  99                 assertEquals("AA", part.newID());
 100                 assertEquals("AB", part.newID());
 101                 assertEquals("AC", part.newID());
 102
 103                 part = new AlphabeticIDGeneratorPart("A", "Z", "ZX");
 104                 assertEquals("ZX", part.newID());
 105                 assertEquals("ZY", part.newID());
 106                 assertEquals("ZZ", part.newID());
 107
 108         }
 109
 110         public void testnewIDUppercase2CharsRolloverFirst() {
 111
 112                 part = new AlphabeticIDGeneratorPart("A", "Z", "AY");
 113                 assertEquals("AY", part.newID());
 114                 assertEquals("AZ", part.newID());
 115                 assertEquals("BA", part.newID());
 116                 assertEquals("BB", part.newID());
 117
 118   }
 119
 120         public void testInitialLowercase() {
 121
 122                 part = new AlphabeticIDGeneratorPart("aaa");
 123                 assertEquals("aaa", part.getInitialID());
 124
 125         }
 126
 127         public void testInitialUppercase() {
 128
 129                 part = new AlphabeticIDGeneratorPart("A", "Z", "AZ");
 130                 assertEquals("AZ", part.getInitialID());
 131
 132         }
 133
 134         public void testCurrentLowercase() {
 135
 136                 part = new AlphabeticIDGeneratorPart("aaa");
 137                 assertEquals("aaa", part.getCurrentID());
 138                 assertEquals("aaa", part.newID());
 139                 assertEquals("aab", part.newID());
 140                 assertEquals("aac", part.newID());
 141                 assertEquals("aac", part.getCurrentID());
 142                 assertEquals("aad", part.newID());
 143
 144         }
 145
 146         public void testCurrentUppercase() {
 147
 148                 part = new AlphabeticIDGeneratorPart("A", "Z", "A");
 149                 assertEquals("A", part.getCurrentID());
 150                 assertEquals("A", part.newID());
 151                 assertEquals("B", part.newID());
 152                 assertEquals("C", part.newID());
 153                 assertEquals("C", part.getCurrentID());
 154                 assertEquals("D", part.newID());
 155
 156         }
 157
 158         public void testOverflowLowercase() {
 159
 160         part = new AlphabeticIDGeneratorPart("zx");
 161         assertEquals("zx", part.newID());
 162         assertEquals("zy", part.newID());
 163         assertEquals("zz", part.newID());
 164         assertEquals("aaa", part.newID());
 165
 166         }
 167
 168         public void testOverflowUppercase() {
 169
 170         part = new AlphabeticIDGeneratorPart("A", "Z", "X");
 171         assertEquals("X", part.newID());
 172         assertEquals("Y", part.newID());
 173         assertEquals("Z", part.newID());
 174         assertEquals("AA", part.newID());
 175
 176         }
 177
 178         public void testNonAlphabeticInitialValue() {
 179                 try {
 180                         part = new AlphabeticIDGeneratorPart("&*432");
 181                         fail("Should have thrown IllegalArgumentException here");
 182                 } catch (IllegalArgumentException expected) {
 183                         // This Exception should be thrown, and thus the test should pass.
 184                 }
 185         }
 186
 187         public void testNullInitialValue() {
 188                 try {
 189                         part = new AlphabeticIDGeneratorPart(null);
 190                         fail("Should have thrown IllegalArgumentException here");
 191                 } catch (IllegalArgumentException expected) {
 192                         // This Exception should be thrown, and thus the test should pass.
 193                 }
 194         }
 195
 196         public void testEmptyStringInitialValue() {
 197                 try {
 198                         part = new AlphabeticIDGeneratorPart("");
 199                         fail("Should have thrown IllegalArgumentException here");
 200                 } catch (IllegalArgumentException expected) {
 201                         // This Exception should be thrown, and thus the test should pass.
 202                 }
 203         }
 204
 205         public void testAllSpaceCharsInitialValue() {
 206                 try {
 207                         part = new AlphabeticIDGeneratorPart("  ");
 208                         fail("Should have thrown IllegalArgumentException here");
 209                 } catch (IllegalArgumentException expected) {
 210                         // This Exception should be thrown, and thus the test should pass.
 211                 }
 212         }
 213
 214         public void testIsValidIDDefaultSeries() {
 215
 216                 part = new AlphabeticIDGeneratorPart();
 217
 218                 assertTrue(part.isValidID("a"));
 219                 assertTrue(part.isValidID("z"));
 220
 221                 assertFalse(part.isValidID("A"));
 222                 assertFalse(part.isValidID("123"));
 223
 224         }
 225
 226         public void testIsValidIDConstrainedLowerCaseSeries() {
 227
 228                 part = new AlphabeticIDGeneratorPart("a", "f", "a");
 229
 230                 assertTrue(part.isValidID("a"));
 231                 assertTrue(part.isValidID("b"));
 232                 assertTrue(part.isValidID("f"));
 233
 234                 assertFalse(part.isValidID("g"));
 235                 assertFalse(part.isValidID("z"));
 236                 assertFalse(part.isValidID("A"));
 237                 assertFalse(part.isValidID("123"));
 238
 239         }
 240
 241         public void testIsValidIDConstrainedUppercaseSeries() {
 242
 243                 part = new AlphabeticIDGeneratorPart("A", "F", "A");
 244
 245                 assertTrue(part.isValidID("A"));
 246                 assertTrue(part.isValidID("B"));
 247                 assertTrue(part.isValidID("F"));
 248
 249                 assertFalse(part.isValidID("G"));
 250                 assertFalse(part.isValidID("Z"));
 251                 assertFalse(part.isValidID("a"));
 252                 assertFalse(part.isValidID("123"));
 253
 254         }
 255
 256         // @TODO: Add more tests of boundary conditions, exceptions ...
 257
 258 }