libcore/luni/src/test/java/tests/api/java/util/StringTokenizerTest.java

   1 /*
   2  *  Licensed to the Apache Software Foundation (ASF) under one or more
   3  *  contributor license agreements.  See the NOTICE file distributed with
   4  *  this work for additional information regarding copyright ownership.
   5  *  The ASF licenses this file to You under the Apache License, Version 2.0
   6  *  (the "License"); you may not use this file except in compliance with
   7  *  the License.  You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  */
  17
  18 package tests.api.java.util;
  19
  20 import dalvik.annotation.TestTargetNew;
  21 import dalvik.annotation.TestTargets;
  22 import dalvik.annotation.TestLevel;
  23 import dalvik.annotation.TestTargetClass;
  24
  25 import java.util.NoSuchElementException;
  26 import java.util.StringTokenizer;
  27
  28 @TestTargetClass(StringTokenizer.class)
  29 public class StringTokenizerTest extends junit.framework.TestCase {
  30
  31     /**
  32      * @tests java.util.StringTokenizer#StringTokenizer(java.lang.String)
  33      */
  34     @TestTargetNew(
  35         level = TestLevel.COMPLETE,
  36         notes = "",
  37         method = "StringTokenizer",
  38         args = {java.lang.String.class}
  39     )
  40     public void test_ConstructorLjava_lang_String() {
  41         // Test for method java.util.StringTokenizer(java.lang.String)
  42         try {
  43             new StringTokenizer(null);
  44             fail("NullPointerException is not thrown.");
  45         } catch(NullPointerException npe) {
  46           //expected
  47         }
  48     }
  49
  50     /**
  51      * @tests java.util.StringTokenizer#StringTokenizer(java.lang.String,
  52      *        java.lang.String)
  53      */
  54     @TestTargetNew(
  55         level = TestLevel.COMPLETE,
  56         notes = "",
  57         method = "StringTokenizer",
  58         args = {java.lang.String.class, java.lang.String.class}
  59     )
  60     public void test_ConstructorLjava_lang_StringLjava_lang_String() {
  61         // Test for method java.util.StringTokenizer(java.lang.String,
  62         // java.lang.String)
  63         StringTokenizer st = new StringTokenizer("This:is:a:test:String", ":");
  64         assertTrue("Created incorrect tokenizer", st.countTokens() == 5
  65                 && (st.nextElement().equals("This")));
  66         st = new StringTokenizer("This:is:a:test:String", null);
  67
  68         try {
  69             new StringTokenizer(null, ":");
  70             fail("NullPointerException expected");
  71         } catch (NullPointerException e) {
  72             //expected
  73         }
  74     }
  75
  76     /**
  77      * @tests java.util.StringTokenizer#StringTokenizer(java.lang.String,
  78      *        java.lang.String, boolean)
  79      */
  80     @TestTargetNew(
  81         level = TestLevel.COMPLETE,
  82         notes = "",
  83         method = "StringTokenizer",
  84         args = {java.lang.String.class, java.lang.String.class, boolean.class}
  85     )
  86     public void test_ConstructorLjava_lang_StringLjava_lang_StringZ() {
  87         // Test for method java.util.StringTokenizer(java.lang.String,
  88         // java.lang.String, boolean)
  89         StringTokenizer st = new StringTokenizer("This:is:a:test:String", ":",
  90                 true);
  91         st.nextElement();
  92         assertTrue("Created incorrect tokenizer", st.countTokens() == 8
  93                 && (st.nextElement().equals(":")));
  94         st = new StringTokenizer("This:is:a:test:String", null, true);
  95         st = new StringTokenizer("This:is:a:test:String", null, false);
  96
  97         try {
  98             new StringTokenizer(null, ":", true);
  99             fail("NullPointerException expected");
 100         } catch (NullPointerException e) {
 101             //expected
 102         }
 103     }
 104
 105     /**
 106      * @tests java.util.StringTokenizer#countTokens()
 107      */
 108     @TestTargetNew(
 109         level = TestLevel.COMPLETE,
 110         notes = "",
 111         method = "countTokens",
 112         args = {}
 113     )
 114     public void test_countTokens() {
 115         // Test for method int java.util.StringTokenizer.countTokens()
 116         StringTokenizer st = new StringTokenizer("This is a test String");
 117
 118         assertEquals("Incorrect token count returned", 5, st.countTokens());
 119     }
 120
 121     /**
 122      * @tests java.util.StringTokenizer#hasMoreElements()
 123      */
 124     @TestTargetNew(
 125         level = TestLevel.COMPLETE,
 126         notes = "",
 127         method = "hasMoreElements",
 128         args = {}
 129     )
 130     public void test_hasMoreElements() {
 131         // Test for method boolean java.util.StringTokenizer.hasMoreElements()
 132
 133         StringTokenizer st = new StringTokenizer("This is a test String");
 134         st.nextElement();
 135         assertTrue("hasMoreElements returned incorrect value", st
 136                 .hasMoreElements());
 137         st.nextElement();
 138         st.nextElement();
 139         st.nextElement();
 140         st.nextElement();
 141         assertTrue("hasMoreElements returned incorrect value", !st
 142                 .hasMoreElements());
 143     }
 144
 145     /**
 146      * @tests java.util.StringTokenizer#hasMoreTokens()
 147      */
 148     @TestTargetNew(
 149         level = TestLevel.COMPLETE,
 150         notes = "",
 151         method = "hasMoreTokens",
 152         args = {}
 153     )
 154     public void test_hasMoreTokens() {
 155         // Test for method boolean java.util.StringTokenizer.hasMoreTokens()
 156         StringTokenizer st = new StringTokenizer("This is a test String");
 157         for (int counter = 0; counter < 5; counter++) {
 158             assertTrue(
 159                     "StringTokenizer incorrectly reports it has no more tokens",
 160                     st.hasMoreTokens());
 161             st.nextToken();
 162         }
 163         assertTrue("StringTokenizer incorrectly reports it has more tokens",
 164                 !st.hasMoreTokens());
 165     }
 166
 167     /**
 168      * @tests java.util.StringTokenizer#nextElement()
 169      */
 170     @TestTargetNew(
 171         level = TestLevel.COMPLETE,
 172         notes = "",
 173         method = "nextElement",
 174         args = {}
 175     )
 176     public void test_nextElement() {
 177         // Test for method java.lang.Object
 178         // java.util.StringTokenizer.nextElement()
 179         StringTokenizer st = new StringTokenizer("This is a test String");
 180         assertEquals("nextElement returned incorrect value", "This", ((String) st
 181                 .nextElement()));
 182         assertEquals("nextElement returned incorrect value", "is", ((String) st
 183                 .nextElement()));
 184         assertEquals("nextElement returned incorrect value", "a", ((String) st
 185                 .nextElement()));
 186         assertEquals("nextElement returned incorrect value", "test", ((String) st
 187                 .nextElement()));
 188         assertEquals("nextElement returned incorrect value", "String", ((String) st
 189                 .nextElement()));
 190         try {
 191             st.nextElement();
 192             fail(
 193                     "nextElement failed to throw a NoSuchElementException when it should have been out of elements");
 194         } catch (NoSuchElementException e) {
 195             return;
 196         }
 197     }
 198
 199     /**
 200      * @tests java.util.StringTokenizer#nextToken()
 201      */
 202     @TestTargetNew(
 203         level = TestLevel.COMPLETE,
 204         notes = "",
 205         method = "nextToken",
 206         args = {}
 207     )
 208     public void test_nextToken() {
 209         // Test for method java.lang.String
 210         // java.util.StringTokenizer.nextToken()
 211         StringTokenizer st = new StringTokenizer("This is a test String");
 212         assertEquals("nextToken returned incorrect value",
 213                 "This", st.nextToken());
 214         assertEquals("nextToken returned incorrect value",
 215                 "is", st.nextToken());
 216         assertEquals("nextToken returned incorrect value",
 217                 "a", st.nextToken());
 218         assertEquals("nextToken returned incorrect value",
 219                 "test", st.nextToken());
 220         assertEquals("nextToken returned incorrect value",
 221                 "String", st.nextToken());
 222         try {
 223             st.nextToken();
 224             fail(
 225                     "nextToken failed to throw a NoSuchElementException when it should have been out of elements");
 226         } catch (NoSuchElementException e) {
 227             return;
 228         }
 229     }
 230
 231     /**
 232      * @tests java.util.StringTokenizer#nextToken(java.lang.String)
 233      */
 234     @TestTargetNew(
 235         level = TestLevel.COMPLETE,
 236         notes = "",
 237         method = "nextToken",
 238         args = {java.lang.String.class}
 239     )
 240     public void test_nextTokenLjava_lang_String() {
 241         // Test for method java.lang.String
 242         // java.util.StringTokenizer.nextToken(java.lang.String)
 243         StringTokenizer st = new StringTokenizer("This is a test String");
 244         assertEquals("nextToken(String) returned incorrect value with normal token String",
 245                 "This", st.nextToken(" "));
 246         assertEquals("nextToken(String) returned incorrect value with custom token String",
 247                 " is a ", st.nextToken("tr"));
 248         assertEquals("calling nextToken() did not use the new default delimiter list",
 249                 "es", st.nextToken());
 250         st = new StringTokenizer("This:is:a:test:String", " ");
 251         assertTrue(st.nextToken(":").equals("This"));
 252         assertTrue(st.nextToken(":").equals("is"));
 253         assertTrue(st.nextToken(":").equals("a"));
 254         assertTrue(st.nextToken(":").equals("test"));
 255         assertTrue(st.nextToken(":").equals("String"));
 256
 257         try {
 258             st.nextToken(":");
 259             fail("NoSuchElementException expected");
 260         } catch (NoSuchElementException e) {
 261             //expected
 262         }
 263
 264         try {
 265             st.nextToken(null);
 266             fail("NullPointerException expected");
 267         } catch (NullPointerException e) {
 268             //expected
 269         }
 270     }
 271
 272     /**
 273      * Sets up the fixture, for example, open a network connection. This method
 274      * is called before a test is executed.
 275      */
 276     protected void setUp() {
 277     }
 278
 279     /**
 280      * Tears down the fixture, for example, close a network connection. This
 281      * method is called after a test is executed.
 282      */
 283     protected void tearDown() {
 284     }
 285 }