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 018 package org.apache.commons.math.complex; 019 020 import java.text.NumberFormat; 021 import java.text.ParseException; 022 import java.text.ParsePosition; 023 import java.util.Locale; 024 025 import org.apache.commons.math.util.CompositeFormat; 026 027 import junit.framework.TestCase; 028 029 public abstract class ComplexFormatAbstractTest extends TestCase { 030 031 CompositeFormat complexFormat = null; 032 ComplexFormat complexFormatJ = null; 033 034 protected abstract Locale getLocale(); 035 036 protected abstract char getDecimalCharacter(); 037 038 @Override 039 protected void setUp() throws Exception { 040 complexFormat = ComplexFormat.getInstance(getLocale()); 041 complexFormatJ = ComplexFormat.getInstance(getLocale()); 042 complexFormatJ.setImaginaryCharacter("j"); 043 } 044 045 public void testSimpleNoDecimals() { 046 Complex c = new Complex(1, 1); 047 String expected = "1 + 1i"; 048 String actual = complexFormat.format(c); 049 assertEquals(expected, actual); 050 } 051 052 public void testSimpleWithDecimals() { 053 Complex c = new Complex(1.23, 1.43); 054 String expected = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i"; 055 String actual = complexFormat.format(c); 056 assertEquals(expected, actual); 057 } 058 059 public void testSimpleWithDecimalsTrunc() { 060 Complex c = new Complex(1.2323, 1.4343); 061 String expected = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i"; 062 String actual = complexFormat.format(c); 063 assertEquals(expected, actual); 064 } 065 066 public void testNegativeReal() { 067 Complex c = new Complex(-1.2323, 1.4343); 068 String expected = "-1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i"; 069 String actual = complexFormat.format(c); 070 assertEquals(expected, actual); 071 } 072 073 public void testNegativeImaginary() { 074 Complex c = new Complex(1.2323, -1.4343); 075 String expected = "1" + getDecimalCharacter() + "23 - 1" + getDecimalCharacter() + "43i"; 076 String actual = complexFormat.format(c); 077 assertEquals(expected, actual); 078 } 079 080 public void testNegativeBoth() { 081 Complex c = new Complex(-1.2323, -1.4343); 082 String expected = "-1" + getDecimalCharacter() + "23 - 1" + getDecimalCharacter() + "43i"; 083 String actual = complexFormat.format(c); 084 assertEquals(expected, actual); 085 } 086 087 public void testZeroReal() { 088 Complex c = new Complex(0.0, -1.4343); 089 String expected = "0 - 1" + getDecimalCharacter() + "43i"; 090 String actual = complexFormat.format(c); 091 assertEquals(expected, actual); 092 } 093 094 public void testZeroImaginary() { 095 Complex c = new Complex(30.233, 0); 096 String expected = "30" + getDecimalCharacter() + "23"; 097 String actual = complexFormat.format(c); 098 assertEquals(expected, actual); 099 } 100 101 public void testDifferentImaginaryChar() { 102 Complex c = new Complex(1, 1); 103 String expected = "1 + 1j"; 104 String actual = complexFormatJ.format(c); 105 assertEquals(expected, actual); 106 } 107 108 public void testStaticFormatComplex() { 109 Locale defaultLocal = Locale.getDefault(); 110 Locale.setDefault(getLocale()); 111 112 Complex c = new Complex(232.222, -342.33); 113 String expected = "232" + getDecimalCharacter() + "22 - 342" + getDecimalCharacter() + "33i"; 114 String actual = ComplexFormat.formatComplex(c); 115 assertEquals(expected, actual); 116 117 Locale.setDefault(defaultLocal); 118 } 119 120 public void testNan() { 121 Complex c = new Complex(Double.NaN, Double.NaN); 122 String expected = "(NaN) + (NaN)i"; 123 String actual = complexFormat.format(c); 124 assertEquals(expected, actual); 125 } 126 127 public void testPositiveInfinity() { 128 Complex c = new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY); 129 String expected = "(Infinity) + (Infinity)i"; 130 String actual = complexFormat.format(c); 131 assertEquals(expected, actual); 132 } 133 134 public void testNegativeInfinity() { 135 Complex c = new Complex(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY); 136 String expected = "(-Infinity) - (Infinity)i"; 137 String actual = complexFormat.format(c); 138 assertEquals(expected, actual); 139 } 140 141 public void testParseSimpleNoDecimals() { 142 String source = "1 + 1i"; 143 Complex expected = new Complex(1, 1); 144 try { 145 Complex actual = (Complex)complexFormat.parseObject(source); 146 assertEquals(expected, actual); 147 } catch (ParseException ex) { 148 fail(ex.getMessage()); 149 } 150 } 151 152 public void testParseSimpleWithDecimals() { 153 String source = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i"; 154 Complex expected = new Complex(1.23, 1.43); 155 try { 156 Complex actual = (Complex)complexFormat.parseObject(source); 157 assertEquals(expected, actual); 158 } catch (ParseException ex) { 159 fail(ex.getMessage()); 160 } 161 } 162 163 public void testParseSimpleWithDecimalsTrunc() { 164 String source = "1" + getDecimalCharacter() + "2323 + 1" + getDecimalCharacter() + "4343i"; 165 Complex expected = new Complex(1.2323, 1.4343); 166 try { 167 Complex actual = (Complex)complexFormat.parseObject(source); 168 assertEquals(expected, actual); 169 } catch (ParseException ex) { 170 fail(ex.getMessage()); 171 } 172 } 173 174 public void testParseNegativeReal() { 175 String source = "-1" + getDecimalCharacter() + "2323 + 1" + getDecimalCharacter() + "4343i"; 176 Complex expected = new Complex(-1.2323, 1.4343); 177 try { 178 Complex actual = (Complex)complexFormat.parseObject(source); 179 assertEquals(expected, actual); 180 } catch (ParseException ex) { 181 fail(ex.getMessage()); 182 } 183 } 184 185 public void testParseNegativeImaginary() { 186 String source = "1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343i"; 187 Complex expected = new Complex(1.2323, -1.4343); 188 try { 189 Complex actual = (Complex)complexFormat.parseObject(source); 190 assertEquals(expected, actual); 191 } catch (ParseException ex) { 192 fail(ex.getMessage()); 193 } 194 } 195 196 public void testParseNegativeBoth() { 197 String source = "-1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343i"; 198 Complex expected = new Complex(-1.2323, -1.4343); 199 try { 200 Complex actual = (Complex)complexFormat.parseObject(source); 201 assertEquals(expected, actual); 202 } catch (ParseException ex) { 203 fail(ex.getMessage()); 204 } 205 } 206 207 public void testParseZeroReal() { 208 String source = "0" + getDecimalCharacter() + "0 - 1" + getDecimalCharacter() + "4343i"; 209 Complex expected = new Complex(0.0, -1.4343); 210 try { 211 Complex actual = (Complex)complexFormat.parseObject(source); 212 assertEquals(expected, actual); 213 } catch (ParseException ex) { 214 fail(ex.getMessage()); 215 } 216 } 217 218 public void testParseZeroImaginary() { 219 String source = "-1" + getDecimalCharacter() + "2323"; 220 Complex expected = new Complex(-1.2323, 0); 221 try { 222 Complex actual = (Complex)complexFormat.parseObject(source); 223 assertEquals(expected, actual); 224 } catch (ParseException ex) { 225 fail(ex.getMessage()); 226 } 227 } 228 229 public void testParseDifferentImaginaryChar() { 230 String source = "-1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343j"; 231 Complex expected = new Complex(-1.2323, -1.4343); 232 try { 233 Complex actual = (Complex)complexFormatJ.parseObject(source); 234 assertEquals(expected, actual); 235 } catch (ParseException ex) { 236 fail(ex.getMessage()); 237 } 238 } 239 240 public void testParseNan() { 241 String source = "(NaN) + (NaN)i"; 242 Complex expected = new Complex(Double.NaN, Double.NaN); 243 try { 244 Complex actual = (Complex)complexFormat.parseObject(source); 245 assertEquals(expected, actual); 246 } catch (ParseException ex) { 247 fail(ex.getMessage()); 248 } 249 } 250 251 public void testParsePositiveInfinity() { 252 String source = "(Infinity) + (Infinity)i"; 253 Complex expected = new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY); 254 try { 255 Complex actual = (Complex)complexFormat.parseObject(source); 256 assertEquals(expected, actual); 257 } catch (ParseException ex) { 258 fail(ex.getMessage()); 259 } 260 } 261 262 public void testPaseNegativeInfinity() { 263 String source = "(-Infinity) - (Infinity)i"; 264 Complex expected = new Complex(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY); 265 try { 266 Complex actual = (Complex)complexFormat.parseObject(source); 267 assertEquals(expected, actual); 268 } catch (ParseException ex) { 269 fail(ex.getMessage()); 270 } 271 } 272 273 public void testConstructorSingleFormat() { 274 NumberFormat nf = NumberFormat.getInstance(); 275 ComplexFormat cf = new ComplexFormat(nf); 276 assertNotNull(cf); 277 assertEquals(nf, cf.getRealFormat()); 278 } 279 280 public void testGetImaginaryFormat() { 281 NumberFormat nf = NumberFormat.getInstance(); 282 ComplexFormat cf = new ComplexFormat(); 283 284 assertNotSame(nf, cf.getImaginaryFormat()); 285 cf.setImaginaryFormat(nf); 286 assertSame(nf, cf.getImaginaryFormat()); 287 } 288 289 public void testSetImaginaryFormatNull() { 290 try { 291 ComplexFormat cf = new ComplexFormat(); 292 cf.setImaginaryFormat(null); 293 fail(); 294 } catch (IllegalArgumentException ex) { 295 // success 296 } 297 } 298 299 public void testSetRealFormatNull() { 300 try { 301 ComplexFormat cf = new ComplexFormat(); 302 cf.setRealFormat(null); 303 fail(); 304 } catch (IllegalArgumentException ex) { 305 // success 306 } 307 } 308 309 public void testGetRealFormat() { 310 NumberFormat nf = NumberFormat.getInstance(); 311 ComplexFormat cf = new ComplexFormat(); 312 313 assertNotSame(nf, cf.getRealFormat()); 314 cf.setRealFormat(nf); 315 assertSame(nf, cf.getRealFormat()); 316 } 317 318 public void testSetImaginaryCharacterNull() { 319 try { 320 ComplexFormat cf = new ComplexFormat(); 321 cf.setImaginaryCharacter(null); 322 fail(); 323 } catch (IllegalArgumentException ex) { 324 // success 325 } 326 } 327 328 public void testSetImaginaryCharacterEmpty() { 329 try { 330 ComplexFormat cf = new ComplexFormat(); 331 cf.setImaginaryCharacter(""); 332 fail(); 333 } catch (IllegalArgumentException ex) { 334 // success 335 } 336 } 337 338 public void testFormatNumber() { 339 CompositeFormat cf = ComplexFormat.getInstance(getLocale()); 340 Double pi = Double.valueOf(Math.PI); 341 String text = cf.format(pi); 342 assertEquals("3" + getDecimalCharacter() + "14", text); 343 } 344 345 public void testFormatObject() { 346 try { 347 CompositeFormat cf = new ComplexFormat(); 348 Object object = new Object(); 349 cf.format(object); 350 fail(); 351 } catch (IllegalArgumentException ex) { 352 // success 353 } 354 } 355 356 public void testForgottenImaginaryCharacter() { 357 ParsePosition pos = new ParsePosition(0); 358 assertNull(new ComplexFormat().parse("1 + 1", pos)); 359 assertEquals(5, pos.getErrorIndex()); 360 } 361 }