001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.math.stat; 018 019 import java.io.BufferedReader; 020 import java.io.IOException; 021 import java.io.StringReader; 022 import java.util.Iterator; 023 024 import org.apache.commons.math.TestUtils; 025 026 import junit.framework.Test; 027 import junit.framework.TestCase; 028 import junit.framework.TestSuite; 029 030 /** 031 * Test cases for the {@link Frequency} class. 032 * 033 * @version $Revision: 780541 $ $Date: 2009-05-31 20:47:02 -0400 (Sun, 31 May 2009) $ 034 */ 035 036 public final class FrequencyTest extends TestCase { 037 private long oneL = 1; 038 private long twoL = 2; 039 private long threeL = 3; 040 private int oneI = 1; 041 private int twoI = 2; 042 private int threeI=3; 043 private double tolerance = 10E-15; 044 private Frequency f = null; 045 046 public FrequencyTest(String name) { 047 super(name); 048 } 049 050 @Override 051 public void setUp() { 052 f = new Frequency(); 053 } 054 055 public static Test suite() { 056 TestSuite suite = new TestSuite(FrequencyTest.class); 057 suite.setName("Frequency Tests"); 058 return suite; 059 } 060 061 /** test freq counts */ 062 public void testCounts() { 063 assertEquals("total count",0,f.getSumFreq()); 064 f.addValue(oneL); 065 f.addValue(twoL); 066 f.addValue(1); 067 f.addValue(oneI); 068 assertEquals("one frequency count",3,f.getCount(1)); 069 assertEquals("two frequency count",1,f.getCount(2)); 070 assertEquals("three frequency count",0,f.getCount(3)); 071 assertEquals("total count",4,f.getSumFreq()); 072 assertEquals("zero cumulative frequency", 0, f.getCumFreq(0)); 073 assertEquals("one cumulative frequency", 3, f.getCumFreq(1)); 074 assertEquals("two cumulative frequency", 4, f.getCumFreq(2)); 075 assertEquals("Integer argument cum freq",4, f.getCumFreq(Integer.valueOf(2))); 076 assertEquals("five cumulative frequency", 4, f.getCumFreq(5)); 077 assertEquals("foo cumulative frequency", 0, f.getCumFreq("foo")); 078 079 f.clear(); 080 assertEquals("total count",0,f.getSumFreq()); 081 082 // userguide examples ------------------------------------------------------------------- 083 f.addValue("one"); 084 f.addValue("One"); 085 f.addValue("oNe"); 086 f.addValue("Z"); 087 assertEquals("one cumulative frequency", 1 , f.getCount("one")); 088 assertEquals("Z cumulative pct", 0.5, f.getCumPct("Z"), tolerance); 089 assertEquals("z cumulative pct", 1.0, f.getCumPct("z"), tolerance); 090 assertEquals("Ot cumulative pct", 0.25, f.getCumPct("Ot"), tolerance); 091 f.clear(); 092 093 f = null; 094 Frequency f = new Frequency(); 095 f.addValue(1); 096 f.addValue(Integer.valueOf(1)); 097 f.addValue(Long.valueOf(1)); 098 f.addValue(2); 099 f.addValue(Integer.valueOf(-1)); 100 assertEquals("1 count", 3, f.getCount(1)); 101 assertEquals("1 count", 3, f.getCount(Integer.valueOf(1))); 102 assertEquals("0 cum pct", 0.2, f.getCumPct(0), tolerance); 103 assertEquals("1 pct", 0.6, f.getPct(Integer.valueOf(1)), tolerance); 104 assertEquals("-2 cum pct", 0, f.getCumPct(-2), tolerance); 105 assertEquals("10 cum pct", 1, f.getCumPct(10), tolerance); 106 107 f = null; 108 f = new Frequency(String.CASE_INSENSITIVE_ORDER); 109 f.addValue("one"); 110 f.addValue("One"); 111 f.addValue("oNe"); 112 f.addValue("Z"); 113 assertEquals("one count", 3 , f.getCount("one")); 114 assertEquals("Z cumulative pct -- case insensitive", 1 , f.getCumPct("Z"), tolerance); 115 assertEquals("z cumulative pct -- case insensitive", 1 , f.getCumPct("z"), tolerance); 116 117 f = null; 118 f = new Frequency(); 119 assertEquals(0L, f.getCount('a')); 120 assertEquals(0L, f.getCumFreq('b')); 121 TestUtils.assertEquals(Double.NaN, f.getPct('a'), 0.0); 122 TestUtils.assertEquals(Double.NaN, f.getCumPct('b'), 0.0); 123 f.addValue('a'); 124 f.addValue('b'); 125 f.addValue('c'); 126 f.addValue('d'); 127 assertEquals(1L, f.getCount('a')); 128 assertEquals(2L, f.getCumFreq('b')); 129 assertEquals(0.25, f.getPct('a'), 0.0); 130 assertEquals(0.5, f.getCumPct('b'), 0.0); 131 assertEquals(1.0, f.getCumPct('e'), 0.0); 132 } 133 134 /** test pcts */ 135 public void testPcts() { 136 f.addValue(oneL); 137 f.addValue(twoL); 138 f.addValue(oneI); 139 f.addValue(twoI); 140 f.addValue(threeL); 141 f.addValue(threeL); 142 f.addValue(3); 143 f.addValue(threeI); 144 assertEquals("one pct",0.25,f.getPct(1),tolerance); 145 assertEquals("two pct",0.25,f.getPct(Long.valueOf(2)),tolerance); 146 assertEquals("three pct",0.5,f.getPct(threeL),tolerance); 147 assertEquals("five pct",0,f.getPct(5),tolerance); 148 assertEquals("foo pct",0,f.getPct("foo"),tolerance); 149 assertEquals("one cum pct",0.25,f.getCumPct(1),tolerance); 150 assertEquals("two cum pct",0.50,f.getCumPct(Long.valueOf(2)),tolerance); 151 assertEquals("Integer argument",0.50,f.getCumPct(Integer.valueOf(2)),tolerance); 152 assertEquals("three cum pct",1.0,f.getCumPct(threeL),tolerance); 153 assertEquals("five cum pct",1.0,f.getCumPct(5),tolerance); 154 assertEquals("zero cum pct",0.0,f.getCumPct(0),tolerance); 155 assertEquals("foo cum pct",0,f.getCumPct("foo"),tolerance); 156 } 157 158 /** test adding incomparable values */ 159 public void testAdd() { 160 char aChar = 'a'; 161 char bChar = 'b'; 162 String aString = "a"; 163 f.addValue(aChar); 164 f.addValue(bChar); 165 try { 166 f.addValue(aString); 167 fail("Expecting IllegalArgumentException"); 168 } catch (IllegalArgumentException ex) { 169 // expected 170 } 171 try { 172 f.addValue(2); 173 fail("Expecting IllegalArgumentException"); 174 } catch (IllegalArgumentException ex) { 175 // expected 176 } 177 assertEquals("a pct",0.5,f.getPct(aChar),tolerance); 178 assertEquals("b cum pct",1.0,f.getCumPct(bChar),tolerance); 179 assertEquals("a string pct",0.0,f.getPct(aString),tolerance); 180 assertEquals("a string cum pct",0.0,f.getCumPct(aString),tolerance); 181 182 f = new Frequency(); 183 f.addValue("One"); 184 try { 185 f.addValue(new Integer("One")); 186 fail("Expecting IllegalArgumentException"); 187 } catch (IllegalArgumentException ex) { 188 // expected 189 } 190 } 191 192 // Check what happens when non-Comparable objects are added 193 @SuppressWarnings("deprecation") 194 public void testAddNonComparable(){ 195 try { 196 f.addValue(new Object()); // This was previously OK 197 fail("Expected IllegalArgumentException"); 198 } catch (IllegalArgumentException expected) { 199 } 200 f.clear(); 201 f.addValue(1); 202 try { 203 f.addValue(new Object()); 204 fail("Expected IllegalArgumentException"); 205 } catch (IllegalArgumentException expected) { 206 } 207 } 208 209 /** test empty table */ 210 public void testEmptyTable() { 211 assertEquals("freq sum, empty table", 0, f.getSumFreq()); 212 assertEquals("count, empty table", 0, f.getCount(0)); 213 assertEquals("count, empty table",0, f.getCount(Integer.valueOf(0))); 214 assertEquals("cum freq, empty table", 0, f.getCumFreq(0)); 215 assertEquals("cum freq, empty table", 0, f.getCumFreq("x")); 216 assertTrue("pct, empty table", Double.isNaN(f.getPct(0))); 217 assertTrue("pct, empty table", Double.isNaN(f.getPct(Integer.valueOf(0)))); 218 assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(0))); 219 assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(Integer.valueOf(0)))); 220 } 221 222 /** 223 * Tests toString() 224 */ 225 public void testToString(){ 226 f.addValue(oneL); 227 f.addValue(twoL); 228 f.addValue(oneI); 229 f.addValue(twoI); 230 231 String s = f.toString(); 232 //System.out.println(s); 233 assertNotNull(s); 234 BufferedReader reader = new BufferedReader(new StringReader(s)); 235 try { 236 String line = reader.readLine(); // header line 237 assertNotNull(line); 238 239 line = reader.readLine(); // one's or two's line 240 assertNotNull(line); 241 242 line = reader.readLine(); // one's or two's line 243 assertNotNull(line); 244 245 line = reader.readLine(); // no more elements 246 assertNull(line); 247 } catch(IOException ex){ 248 fail(ex.getMessage()); 249 } 250 } 251 public void testIntegerValues() { 252 Comparable<?> obj1 = null; 253 obj1 = Integer.valueOf(1); 254 Integer int1 = Integer.valueOf(1); 255 f.addValue(obj1); 256 f.addValue(int1); 257 f.addValue(2); 258 f.addValue(Long.valueOf(2)); 259 assertEquals("Integer 1 count", 2, f.getCount(1)); 260 assertEquals("Integer 1 count", 2, f.getCount(Integer.valueOf(1))); 261 assertEquals("Integer 1 count", 2, f.getCount(Long.valueOf(1))); 262 assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(1), tolerance); 263 assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(Long.valueOf(1)), tolerance); 264 assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(Integer.valueOf(1)), tolerance); 265 Iterator<?> it = f.valuesIterator(); 266 while (it.hasNext()) { 267 assertTrue(it.next() instanceof Long); 268 } 269 } 270 271 public void testSerial() { 272 f.addValue(oneL); 273 f.addValue(twoL); 274 f.addValue(oneI); 275 f.addValue(twoI); 276 assertEquals(f, TestUtils.serializeAndRecover(f)); 277 } 278 } 279