tests/com/google/common/geometry/S1IntervalTest.java - platform/external/s2-geometry-library-java - Git at Google

 /*
  * Copyright 2005 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.google.common.geometry;


 public strictfp class S1IntervalTest extends GeometryTestCase {

   private void testIntervalOps(S1Interval x, S1Interval y, String expectedRelation,
       S1Interval expectedUnion, S1Interval expectedIntersection) {
     // Test all of the interval operations on the given pair of intervals.
     // "expected_relation" is a sequence of "T" and "F" characters corresponding
     // to the expected results of Contains(), InteriorContains(), Intersects(),
     // and InteriorIntersects() respectively.

     assertEquals(x.contains(y), expectedRelation.charAt(0) == 'T');
     assertEquals(x.interiorContains(y), expectedRelation.charAt(1) == 'T');
     assertEquals(x.intersects(y), expectedRelation.charAt(2) == 'T');
     assertEquals(x.interiorIntersects(y), expectedRelation.charAt(3) == 'T');

     // bounds() returns a const reference to a member variable, so we need to
     // make a copy when invoking it on a temporary object.
     assertEquals(expectedUnion, x.union(y));
     assertEquals(expectedIntersection, x.intersection(y));

     assertEquals(x.contains(y), x.union(y) == x);
     assertEquals(x.intersects(y), !x.intersection(y).isEmpty());

     if (y.lo() == y.hi()) {
       S1Interval r = x.addPoint(y.lo());
       assertEquals(expectedUnion, r);
     }
   }

   public void testBasic() {
     // "Quadrants" are numbered as follows:
     // quad1 == [0, Pi/2]
     // quad2 == [Pi/2, Pi]
     // quad3 == [-Pi, -Pi/2]
     // quad4 == [-Pi/2, 0]

     // Constructors and accessors.
     S1Interval quad12 = new S1Interval(0, -S2.M_PI);
     assertEquals(quad12.lo(), 0.0);
     assertEquals(quad12.hi(), S2.M_PI);
     S1Interval quad34 = new S1Interval(-S2.M_PI, 0);
     assertEquals(quad34.lo(), S2.M_PI);
     assertEquals(quad34.hi(), 0.0);
     S1Interval pi = new S1Interval(S2.M_PI, S2.M_PI);
     assertEquals(pi.lo(), S2.M_PI);
     assertEquals(pi.hi(), S2.M_PI);
     S1Interval mipi = new S1Interval(-S2.M_PI, -S2.M_PI);
     assertEquals(mipi.lo(), S2.M_PI);
     assertEquals(mipi.hi(), S2.M_PI);
     S1Interval quad23 = new S1Interval(S2.M_PI_2, -S2.M_PI_2); // inverted
     assertEquals(quad23.lo(), S2.M_PI_2);
     assertEquals(quad23.hi(), -S2.M_PI_2);
     S1Interval quad1 = new S1Interval(0, S2.M_PI_2);

     // is_valid(), is_empty(), is_inverted()
     S1Interval zero = new S1Interval(0, 0);
     assertTrue(zero.isValid() && !zero.isEmpty() && !zero.isFull());
     S1Interval empty = S1Interval.empty();
     assertTrue(empty.isValid() && empty.isEmpty() && !empty.isFull());
     assertTrue(empty.isInverted());
     S1Interval full = S1Interval.full();
     assertTrue(full.isValid() && !full.isEmpty() && full.isFull());
     assertTrue(!quad12.isEmpty() && !quad12.isFull() && !quad12.isInverted());
     assertTrue(!quad23.isEmpty() && !quad23.isFull() && quad23.isInverted());
     assertTrue(pi.isValid() && !pi.isEmpty() && !pi.isInverted());
     assertTrue(mipi.isValid() && !mipi.isEmpty() && !mipi.isInverted());

     // GetCenter(), GetLength()
     assertEquals(quad12.getCenter(), S2.M_PI_2);
     assertEquals(quad12.getLength(), S2.M_PI);
     assertDoubleNear(new S1Interval(3.1, 2.9).getCenter(), 3.0 - S2.M_PI);
     assertDoubleNear(new S1Interval(-2.9, -3.1).getCenter(), S2.M_PI - 3.0);
     assertDoubleNear(new S1Interval(2.1, -2.1).getCenter(), S2.M_PI);
     assertEquals(pi.getCenter(), S2.M_PI);
     assertEquals(pi.getLength(), 0.0);
     assertEquals(mipi.getCenter(), S2.M_PI);
     assertEquals(mipi.getLength(), 0.0);
     assertEquals(Math.abs(quad23.getCenter()), S2.M_PI);
     assertEquals(Math.abs(quad23.getLength()), S2.M_PI);
     S1Interval quad123 = new S1Interval(0, -S2.M_PI_2);
     assertDoubleNear(quad123.getCenter(), 0.75 * S2.M_PI);
     assertDoubleNear(quad123.getLength(), 1.5 * S2.M_PI);
     assertTrue(empty.getLength() < 0);
     assertEquals(full.getLength(), 2 * S2.M_PI);

     // Complement()
     assertTrue(empty.complement().isFull());
     assertTrue(full.complement().isEmpty());
     assertTrue(pi.complement().isFull());
     assertTrue(mipi.complement().isFull());
     assertTrue(zero.complement().isFull());
     assertTrue(quad12.complement().approxEquals(quad34));
     assertTrue(quad34.complement().approxEquals(quad12));
     S1Interval quad4 = new S1Interval(-S2.M_PI_2, 0);
     assertTrue(quad123.complement().approxEquals(quad4));
     S1Interval quad234 = new S1Interval(S2.M_PI_2, 0);

     // Contains(double), InteriorContains(double)
     assertTrue(!empty.contains(0) && !empty.contains(S2.M_PI) && !empty.contains(-S2.M_PI));
     assertTrue(!empty.interiorContains(S2.M_PI) && !empty.interiorContains(-S2.M_PI));
     assertTrue(full.contains(0) && full.contains(S2.M_PI) && full.contains(-S2.M_PI));
     assertTrue(full.interiorContains(S2.M_PI) && full.interiorContains(-S2.M_PI));
     assertTrue(quad12.contains(0) && quad12.contains(S2.M_PI) && quad12.contains(-S2.M_PI));
     assertTrue(quad12.interiorContains(S2.M_PI_2) && !quad12.interiorContains(0));
     assertTrue(!quad12.interiorContains(S2.M_PI) && !quad12.interiorContains(-S2.M_PI));
     assertTrue(quad23.contains(S2.M_PI_2) && quad23.contains(-S2.M_PI_2));
     assertTrue(quad23.contains(S2.M_PI) && quad23.contains(-S2.M_PI));
     assertTrue(!quad23.contains(0));
     assertTrue(!quad23.interiorContains(S2.M_PI_2) && !quad23.interiorContains(-S2.M_PI_2));
     assertTrue(quad23.interiorContains(S2.M_PI) && quad23.interiorContains(-S2.M_PI));
     assertTrue(!quad23.interiorContains(0));
     assertTrue(pi.contains(S2.M_PI) && pi.contains(-S2.M_PI) && !pi.contains(0));
     assertTrue(!pi.interiorContains(S2.M_PI) && !pi.interiorContains(-S2.M_PI));
     assertTrue(mipi.contains(S2.M_PI) && mipi.contains(-S2.M_PI) && !mipi.contains(0));
     assertTrue(!mipi.interiorContains(S2.M_PI) && !mipi.interiorContains(-S2.M_PI));
     assertTrue(zero.contains(0) && !zero.interiorContains(0));

     // Contains(S1Interval), InteriorContains(S1Interval),
     // Intersects(), InteriorIntersects(), Union(), Intersection()
     S1Interval quad2 = new S1Interval(S2.M_PI_2, -S2.M_PI);
     S1Interval quad3 = new S1Interval(S2.M_PI, -S2.M_PI_2);
     S1Interval pi2 = new S1Interval(S2.M_PI_2, S2.M_PI_2);
     S1Interval mipi2 = new S1Interval(-S2.M_PI_2, -S2.M_PI_2);

     testIntervalOps(empty, empty, "TTFF", empty, empty);
     testIntervalOps(empty, full, "FFFF", full, empty);
     testIntervalOps(empty, zero, "FFFF", zero, empty);
     testIntervalOps(empty, pi, "FFFF", pi, empty);
     testIntervalOps(empty, mipi, "FFFF", mipi, empty);

     testIntervalOps(full, empty, "TTFF", full, empty);
     testIntervalOps(full, full, "TTTT", full, full);
     testIntervalOps(full, zero, "TTTT", full, zero);
     testIntervalOps(full, pi, "TTTT", full, pi);
     testIntervalOps(full, mipi, "TTTT", full, mipi);
     testIntervalOps(full, quad12, "TTTT", full, quad12);
     testIntervalOps(full, quad23, "TTTT", full, quad23);

     testIntervalOps(zero, empty, "TTFF", zero, empty);
     testIntervalOps(zero, full, "FFTF", full, zero);
     testIntervalOps(zero, zero, "TFTF", zero, zero);
     testIntervalOps(zero, pi, "FFFF", new S1Interval(0, S2.M_PI), empty);
     testIntervalOps(zero, pi2, "FFFF", quad1, empty);
     testIntervalOps(zero, mipi, "FFFF", quad12, empty);
     testIntervalOps(zero, mipi2, "FFFF", quad4, empty);
     testIntervalOps(zero, quad12, "FFTF", quad12, zero);
     testIntervalOps(zero, quad23, "FFFF", quad123, empty);

     testIntervalOps(pi2, empty, "TTFF", pi2, empty);
     testIntervalOps(pi2, full, "FFTF", full, pi2);
     testIntervalOps(pi2, zero, "FFFF", quad1, empty);
     testIntervalOps(pi2, pi, "FFFF", new S1Interval(S2.M_PI_2, S2.M_PI), empty);
     testIntervalOps(pi2, pi2, "TFTF", pi2, pi2);
     testIntervalOps(pi2, mipi, "FFFF", quad2, empty);
     testIntervalOps(pi2, mipi2, "FFFF", quad23, empty);
     testIntervalOps(pi2, quad12, "FFTF", quad12, pi2);
     testIntervalOps(pi2, quad23, "FFTF", quad23, pi2);

     testIntervalOps(pi, empty, "TTFF", pi, empty);
     testIntervalOps(pi, full, "FFTF", full, pi);
     testIntervalOps(pi, zero, "FFFF", new S1Interval(S2.M_PI, 0), empty);
     testIntervalOps(pi, pi, "TFTF", pi, pi);
     testIntervalOps(pi, pi2, "FFFF", new S1Interval(S2.M_PI_2, S2.M_PI), empty);
     testIntervalOps(pi, mipi, "TFTF", pi, pi);
     testIntervalOps(pi, mipi2, "FFFF", quad3, empty);
     testIntervalOps(pi, quad12, "FFTF", new S1Interval(0, S2.M_PI), pi);
     testIntervalOps(pi, quad23, "FFTF", quad23, pi);

     testIntervalOps(mipi, empty, "TTFF", mipi, empty);
     testIntervalOps(mipi, full, "FFTF", full, mipi);
     testIntervalOps(mipi, zero, "FFFF", quad34, empty);
     testIntervalOps(mipi, pi, "TFTF", mipi, mipi);
     testIntervalOps(mipi, pi2, "FFFF", quad2, empty);
     testIntervalOps(mipi, mipi, "TFTF", mipi, mipi);
     testIntervalOps(mipi, mipi2, "FFFF", new S1Interval(-S2.M_PI, -S2.M_PI_2), empty);
     testIntervalOps(mipi, quad12, "FFTF", quad12, mipi);
     testIntervalOps(mipi, quad23, "FFTF", quad23, mipi);

     testIntervalOps(quad12, empty, "TTFF", quad12, empty);
     testIntervalOps(quad12, full, "FFTT", full, quad12);
     testIntervalOps(quad12, zero, "TFTF", quad12, zero);
     testIntervalOps(quad12, pi, "TFTF", quad12, pi);
     testIntervalOps(quad12, mipi, "TFTF", quad12, mipi);
     testIntervalOps(quad12, quad12, "TFTT", quad12, quad12);
     testIntervalOps(quad12, quad23, "FFTT", quad123, quad2);
     testIntervalOps(quad12, quad34, "FFTF", full, quad12);

     testIntervalOps(quad23, empty, "TTFF", quad23, empty);
     testIntervalOps(quad23, full, "FFTT", full, quad23);
     testIntervalOps(quad23, zero, "FFFF", quad234, empty);
     testIntervalOps(quad23, pi, "TTTT", quad23, pi);
     testIntervalOps(quad23, mipi, "TTTT", quad23, mipi);
     testIntervalOps(quad23, quad12, "FFTT", quad123, quad2);
     testIntervalOps(quad23, quad23, "TFTT", quad23, quad23);
     testIntervalOps(quad23, quad34, "FFTT", quad234, new S1Interval(-S2.M_PI, -S2.M_PI_2));

     testIntervalOps(quad1, quad23, "FFTF", quad123, new S1Interval(S2.M_PI_2, S2.M_PI_2));
     testIntervalOps(quad2, quad3, "FFTF", quad23, mipi);
     testIntervalOps(quad3, quad2, "FFTF", quad23, pi);
     testIntervalOps(quad2, pi, "TFTF", quad2, pi);
     testIntervalOps(quad2, mipi, "TFTF", quad2, mipi);
     testIntervalOps(quad3, pi, "TFTF", quad3, pi);
     testIntervalOps(quad3, mipi, "TFTF", quad3, mipi);

     S1Interval mid12 = new S1Interval(S2.M_PI_2 - 0.02, S2.M_PI_2 + 0.01);
     S1Interval mid23 = new S1Interval(S2.M_PI - 0.01, -S2.M_PI + 0.02);
     S1Interval mid34 = new S1Interval(-S2.M_PI_2 - 0.02, -S2.M_PI_2 + 0.01);
     S1Interval mid41 = new S1Interval(-0.01, 0.02);

     S1Interval quad2hi = new S1Interval(mid23.lo(), quad12.hi());
     S1Interval quad1lo = new S1Interval(quad12.lo(), mid41.hi());
     S1Interval quad12eps = new S1Interval(quad12.lo(), mid23.hi());
     S1Interval quadeps12 = new S1Interval(mid41.lo(), quad12.hi());
     S1Interval quad123eps = new S1Interval(quad12.lo(), mid34.hi());
     testIntervalOps(quad12, mid12, "TTTT", quad12, mid12);
     testIntervalOps(mid12, quad12, "FFTT", quad12, mid12);
     testIntervalOps(quad12, mid23, "FFTT", quad12eps, quad2hi);
     testIntervalOps(mid23, quad12, "FFTT", quad12eps, quad2hi);
     testIntervalOps(quad12, mid34, "FFFF", quad123eps, empty);
     testIntervalOps(mid34, quad12, "FFFF", quad123eps, empty);
     testIntervalOps(quad12, mid41, "FFTT", quadeps12, quad1lo);
     testIntervalOps(mid41, quad12, "FFTT", quadeps12, quad1lo);

     S1Interval quad2lo = new S1Interval(quad23.lo(), mid12.hi());
     S1Interval quad3hi = new S1Interval(mid34.lo(), quad23.hi());
     S1Interval quadeps23 = new S1Interval(mid12.lo(), quad23.hi());
     S1Interval quad23eps = new S1Interval(quad23.lo(), mid34.hi());
     S1Interval quadeps123 = new S1Interval(mid41.lo(), quad23.hi());
     testIntervalOps(quad23, mid12, "FFTT", quadeps23, quad2lo);
     testIntervalOps(mid12, quad23, "FFTT", quadeps23, quad2lo);
     testIntervalOps(quad23, mid23, "TTTT", quad23, mid23);
     testIntervalOps(mid23, quad23, "FFTT", quad23, mid23);
     testIntervalOps(quad23, mid34, "FFTT", quad23eps, quad3hi);
     testIntervalOps(mid34, quad23, "FFTT", quad23eps, quad3hi);
     testIntervalOps(quad23, mid41, "FFFF", quadeps123, empty);
     testIntervalOps(mid41, quad23, "FFFF", quadeps123, empty);

     // AddPoint()
     S1Interval r = S1Interval.empty();
     S1Interval res;
     res = r.addPoint(0);
     assertEquals(res, zero);

     res = r.addPoint(S2.M_PI);
     assertEquals(res, pi);

     res = r.addPoint(-S2.M_PI);
     assertEquals(res, mipi);

     res = r.addPoint(S2.M_PI);
     res = res.addPoint(-S2.M_PI);
     assertEquals(res, pi);

     res = res.addPoint(-S2.M_PI);
     res.addPoint(S2.M_PI);
     assertEquals(res, mipi);

     res = r.addPoint(mid12.lo());
     res = res.addPoint(mid12.hi());
     assertEquals(res, mid12);

     res = r.addPoint(mid23.lo());
     res = res.addPoint(mid23.hi());
     assertEquals(res, mid23);

     res = quad1.addPoint(-0.9 * S2.M_PI);
     res = res.addPoint(-S2.M_PI_2);
     assertEquals(res, quad123);

     r = S1Interval.full();
     res = r.addPoint(0);
     assertTrue(res.isFull());

     res = r.addPoint(S2.M_PI);
     assertTrue(res.isFull());

     res = r.addPoint(-S2.M_PI);
     assertTrue(res.isFull());

     // FromPointPair()
     assertEquals(S1Interval.fromPointPair(-S2.M_PI, S2.M_PI), pi);
     assertEquals(S1Interval.fromPointPair(S2.M_PI, -S2.M_PI), pi);
     assertEquals(S1Interval.fromPointPair(mid34.hi(), mid34.lo()), mid34);
     assertEquals(S1Interval.fromPointPair(mid23.lo(), mid23.hi()), mid23);

     // Expanded()
     assertEquals(empty.expanded(1), empty);
     assertEquals(full.expanded(1), full);
     assertEquals(zero.expanded(1), new S1Interval(-1, 1));
     assertEquals(mipi.expanded(0.01), new S1Interval(S2.M_PI - 0.01, -S2.M_PI + 0.01));
     assertEquals(pi.expanded(27), full);
     assertEquals(pi.expanded(S2.M_PI_2), quad23);
     assertEquals(pi2.expanded(S2.M_PI_2), quad12);
     assertEquals(mipi2.expanded(S2.M_PI_2), quad34);

     // ApproxEquals()
     assertTrue(empty.approxEquals(empty));
     assertTrue(zero.approxEquals(empty) && empty.approxEquals(zero));
     assertTrue(pi.approxEquals(empty) && empty.approxEquals(pi));
     assertTrue(mipi.approxEquals(empty) && empty.approxEquals(mipi));
     assertTrue(pi.approxEquals(mipi) && mipi.approxEquals(pi));
     assertTrue(pi.union(mipi).approxEquals(pi));
     assertTrue(mipi.union(pi).approxEquals(pi));
     assertTrue(pi.union(mid12).union(zero).approxEquals(quad12));
     assertTrue(quad2.intersection(quad3).approxEquals(pi));
     assertTrue(quad3.intersection(quad2).approxEquals(pi));
   }
 }
	/*
	* Copyright 2005 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.google.common.geometry;


	public strictfp class S1IntervalTest extends GeometryTestCase {

	private void testIntervalOps(S1Interval x, S1Interval y, String expectedRelation,
	S1Interval expectedUnion, S1Interval expectedIntersection) {
	// Test all of the interval operations on the given pair of intervals.
	// "expected_relation" is a sequence of "T" and "F" characters corresponding
	// to the expected results of Contains(), InteriorContains(), Intersects(),
	// and InteriorIntersects() respectively.

	assertEquals(x.contains(y), expectedRelation.charAt(0) == 'T');
	assertEquals(x.interiorContains(y), expectedRelation.charAt(1) == 'T');
	assertEquals(x.intersects(y), expectedRelation.charAt(2) == 'T');
	assertEquals(x.interiorIntersects(y), expectedRelation.charAt(3) == 'T');

	// bounds() returns a const reference to a member variable, so we need to
	// make a copy when invoking it on a temporary object.
	assertEquals(expectedUnion, x.union(y));
	assertEquals(expectedIntersection, x.intersection(y));

	assertEquals(x.contains(y), x.union(y) == x);
	assertEquals(x.intersects(y), !x.intersection(y).isEmpty());

	if (y.lo() == y.hi()) {
	S1Interval r = x.addPoint(y.lo());
	assertEquals(expectedUnion, r);
	}
	}

	public void testBasic() {
	// "Quadrants" are numbered as follows:
	// quad1 == [0, Pi/2]
	// quad2 == [Pi/2, Pi]
	// quad3 == [-Pi, -Pi/2]
	// quad4 == [-Pi/2, 0]

	// Constructors and accessors.
	S1Interval quad12 = new S1Interval(0, -S2.M_PI);
	assertEquals(quad12.lo(), 0.0);
	assertEquals(quad12.hi(), S2.M_PI);
	S1Interval quad34 = new S1Interval(-S2.M_PI, 0);
	assertEquals(quad34.lo(), S2.M_PI);
	assertEquals(quad34.hi(), 0.0);
	S1Interval pi = new S1Interval(S2.M_PI, S2.M_PI);
	assertEquals(pi.lo(), S2.M_PI);
	assertEquals(pi.hi(), S2.M_PI);
	S1Interval mipi = new S1Interval(-S2.M_PI, -S2.M_PI);
	assertEquals(mipi.lo(), S2.M_PI);
	assertEquals(mipi.hi(), S2.M_PI);
	S1Interval quad23 = new S1Interval(S2.M_PI_2, -S2.M_PI_2); // inverted
	assertEquals(quad23.lo(), S2.M_PI_2);
	assertEquals(quad23.hi(), -S2.M_PI_2);
	S1Interval quad1 = new S1Interval(0, S2.M_PI_2);

	// is_valid(), is_empty(), is_inverted()
	S1Interval zero = new S1Interval(0, 0);
	assertTrue(zero.isValid() && !zero.isEmpty() && !zero.isFull());
	S1Interval empty = S1Interval.empty();
	assertTrue(empty.isValid() && empty.isEmpty() && !empty.isFull());
	assertTrue(empty.isInverted());
	S1Interval full = S1Interval.full();
	assertTrue(full.isValid() && !full.isEmpty() && full.isFull());
	assertTrue(!quad12.isEmpty() && !quad12.isFull() && !quad12.isInverted());
	assertTrue(!quad23.isEmpty() && !quad23.isFull() && quad23.isInverted());
	assertTrue(pi.isValid() && !pi.isEmpty() && !pi.isInverted());
	assertTrue(mipi.isValid() && !mipi.isEmpty() && !mipi.isInverted());

	// GetCenter(), GetLength()
	assertEquals(quad12.getCenter(), S2.M_PI_2);
	assertEquals(quad12.getLength(), S2.M_PI);
	assertDoubleNear(new S1Interval(3.1, 2.9).getCenter(), 3.0 - S2.M_PI);
	assertDoubleNear(new S1Interval(-2.9, -3.1).getCenter(), S2.M_PI - 3.0);
	assertDoubleNear(new S1Interval(2.1, -2.1).getCenter(), S2.M_PI);
	assertEquals(pi.getCenter(), S2.M_PI);
	assertEquals(pi.getLength(), 0.0);
	assertEquals(mipi.getCenter(), S2.M_PI);
	assertEquals(mipi.getLength(), 0.0);
	assertEquals(Math.abs(quad23.getCenter()), S2.M_PI);
	assertEquals(Math.abs(quad23.getLength()), S2.M_PI);
	S1Interval quad123 = new S1Interval(0, -S2.M_PI_2);
	assertDoubleNear(quad123.getCenter(), 0.75 * S2.M_PI);
	assertDoubleNear(quad123.getLength(), 1.5 * S2.M_PI);
	assertTrue(empty.getLength() < 0);
	assertEquals(full.getLength(), 2 * S2.M_PI);

	// Complement()
	assertTrue(empty.complement().isFull());
	assertTrue(full.complement().isEmpty());
	assertTrue(pi.complement().isFull());
	assertTrue(mipi.complement().isFull());
	assertTrue(zero.complement().isFull());
	assertTrue(quad12.complement().approxEquals(quad34));
	assertTrue(quad34.complement().approxEquals(quad12));
	S1Interval quad4 = new S1Interval(-S2.M_PI_2, 0);
	assertTrue(quad123.complement().approxEquals(quad4));
	S1Interval quad234 = new S1Interval(S2.M_PI_2, 0);

	// Contains(double), InteriorContains(double)
	assertTrue(!empty.contains(0) && !empty.contains(S2.M_PI) && !empty.contains(-S2.M_PI));
	assertTrue(!empty.interiorContains(S2.M_PI) && !empty.interiorContains(-S2.M_PI));
	assertTrue(full.contains(0) && full.contains(S2.M_PI) && full.contains(-S2.M_PI));
	assertTrue(full.interiorContains(S2.M_PI) && full.interiorContains(-S2.M_PI));
	assertTrue(quad12.contains(0) && quad12.contains(S2.M_PI) && quad12.contains(-S2.M_PI));
	assertTrue(quad12.interiorContains(S2.M_PI_2) && !quad12.interiorContains(0));
	assertTrue(!quad12.interiorContains(S2.M_PI) && !quad12.interiorContains(-S2.M_PI));
	assertTrue(quad23.contains(S2.M_PI_2) && quad23.contains(-S2.M_PI_2));
	assertTrue(quad23.contains(S2.M_PI) && quad23.contains(-S2.M_PI));
	assertTrue(!quad23.contains(0));
	assertTrue(!quad23.interiorContains(S2.M_PI_2) && !quad23.interiorContains(-S2.M_PI_2));
	assertTrue(quad23.interiorContains(S2.M_PI) && quad23.interiorContains(-S2.M_PI));
	assertTrue(!quad23.interiorContains(0));
	assertTrue(pi.contains(S2.M_PI) && pi.contains(-S2.M_PI) && !pi.contains(0));
	assertTrue(!pi.interiorContains(S2.M_PI) && !pi.interiorContains(-S2.M_PI));
	assertTrue(mipi.contains(S2.M_PI) && mipi.contains(-S2.M_PI) && !mipi.contains(0));
	assertTrue(!mipi.interiorContains(S2.M_PI) && !mipi.interiorContains(-S2.M_PI));
	assertTrue(zero.contains(0) && !zero.interiorContains(0));

	// Contains(S1Interval), InteriorContains(S1Interval),
	// Intersects(), InteriorIntersects(), Union(), Intersection()
	S1Interval quad2 = new S1Interval(S2.M_PI_2, -S2.M_PI);
	S1Interval quad3 = new S1Interval(S2.M_PI, -S2.M_PI_2);
	S1Interval pi2 = new S1Interval(S2.M_PI_2, S2.M_PI_2);
	S1Interval mipi2 = new S1Interval(-S2.M_PI_2, -S2.M_PI_2);

	testIntervalOps(empty, empty, "TTFF", empty, empty);
	testIntervalOps(empty, full, "FFFF", full, empty);
	testIntervalOps(empty, zero, "FFFF", zero, empty);
	testIntervalOps(empty, pi, "FFFF", pi, empty);
	testIntervalOps(empty, mipi, "FFFF", mipi, empty);

	testIntervalOps(full, empty, "TTFF", full, empty);
	testIntervalOps(full, full, "TTTT", full, full);
	testIntervalOps(full, zero, "TTTT", full, zero);
	testIntervalOps(full, pi, "TTTT", full, pi);
	testIntervalOps(full, mipi, "TTTT", full, mipi);
	testIntervalOps(full, quad12, "TTTT", full, quad12);
	testIntervalOps(full, quad23, "TTTT", full, quad23);

	testIntervalOps(zero, empty, "TTFF", zero, empty);
	testIntervalOps(zero, full, "FFTF", full, zero);
	testIntervalOps(zero, zero, "TFTF", zero, zero);
	testIntervalOps(zero, pi, "FFFF", new S1Interval(0, S2.M_PI), empty);
	testIntervalOps(zero, pi2, "FFFF", quad1, empty);
	testIntervalOps(zero, mipi, "FFFF", quad12, empty);
	testIntervalOps(zero, mipi2, "FFFF", quad4, empty);
	testIntervalOps(zero, quad12, "FFTF", quad12, zero);
	testIntervalOps(zero, quad23, "FFFF", quad123, empty);

	testIntervalOps(pi2, empty, "TTFF", pi2, empty);
	testIntervalOps(pi2, full, "FFTF", full, pi2);
	testIntervalOps(pi2, zero, "FFFF", quad1, empty);
	testIntervalOps(pi2, pi, "FFFF", new S1Interval(S2.M_PI_2, S2.M_PI), empty);
	testIntervalOps(pi2, pi2, "TFTF", pi2, pi2);
	testIntervalOps(pi2, mipi, "FFFF", quad2, empty);
	testIntervalOps(pi2, mipi2, "FFFF", quad23, empty);
	testIntervalOps(pi2, quad12, "FFTF", quad12, pi2);
	testIntervalOps(pi2, quad23, "FFTF", quad23, pi2);

	testIntervalOps(pi, empty, "TTFF", pi, empty);
	testIntervalOps(pi, full, "FFTF", full, pi);
	testIntervalOps(pi, zero, "FFFF", new S1Interval(S2.M_PI, 0), empty);
	testIntervalOps(pi, pi, "TFTF", pi, pi);
	testIntervalOps(pi, pi2, "FFFF", new S1Interval(S2.M_PI_2, S2.M_PI), empty);
	testIntervalOps(pi, mipi, "TFTF", pi, pi);
	testIntervalOps(pi, mipi2, "FFFF", quad3, empty);
	testIntervalOps(pi, quad12, "FFTF", new S1Interval(0, S2.M_PI), pi);
	testIntervalOps(pi, quad23, "FFTF", quad23, pi);

	testIntervalOps(mipi, empty, "TTFF", mipi, empty);
	testIntervalOps(mipi, full, "FFTF", full, mipi);
	testIntervalOps(mipi, zero, "FFFF", quad34, empty);
	testIntervalOps(mipi, pi, "TFTF", mipi, mipi);
	testIntervalOps(mipi, pi2, "FFFF", quad2, empty);
	testIntervalOps(mipi, mipi, "TFTF", mipi, mipi);
	testIntervalOps(mipi, mipi2, "FFFF", new S1Interval(-S2.M_PI, -S2.M_PI_2), empty);
	testIntervalOps(mipi, quad12, "FFTF", quad12, mipi);
	testIntervalOps(mipi, quad23, "FFTF", quad23, mipi);

	testIntervalOps(quad12, empty, "TTFF", quad12, empty);
	testIntervalOps(quad12, full, "FFTT", full, quad12);
	testIntervalOps(quad12, zero, "TFTF", quad12, zero);
	testIntervalOps(quad12, pi, "TFTF", quad12, pi);
	testIntervalOps(quad12, mipi, "TFTF", quad12, mipi);
	testIntervalOps(quad12, quad12, "TFTT", quad12, quad12);
	testIntervalOps(quad12, quad23, "FFTT", quad123, quad2);
	testIntervalOps(quad12, quad34, "FFTF", full, quad12);

	testIntervalOps(quad23, empty, "TTFF", quad23, empty);
	testIntervalOps(quad23, full, "FFTT", full, quad23);
	testIntervalOps(quad23, zero, "FFFF", quad234, empty);
	testIntervalOps(quad23, pi, "TTTT", quad23, pi);
	testIntervalOps(quad23, mipi, "TTTT", quad23, mipi);
	testIntervalOps(quad23, quad12, "FFTT", quad123, quad2);
	testIntervalOps(quad23, quad23, "TFTT", quad23, quad23);
	testIntervalOps(quad23, quad34, "FFTT", quad234, new S1Interval(-S2.M_PI, -S2.M_PI_2));

	testIntervalOps(quad1, quad23, "FFTF", quad123, new S1Interval(S2.M_PI_2, S2.M_PI_2));
	testIntervalOps(quad2, quad3, "FFTF", quad23, mipi);
	testIntervalOps(quad3, quad2, "FFTF", quad23, pi);
	testIntervalOps(quad2, pi, "TFTF", quad2, pi);
	testIntervalOps(quad2, mipi, "TFTF", quad2, mipi);
	testIntervalOps(quad3, pi, "TFTF", quad3, pi);
	testIntervalOps(quad3, mipi, "TFTF", quad3, mipi);

	S1Interval mid12 = new S1Interval(S2.M_PI_2 - 0.02, S2.M_PI_2 + 0.01);
	S1Interval mid23 = new S1Interval(S2.M_PI - 0.01, -S2.M_PI + 0.02);
	S1Interval mid34 = new S1Interval(-S2.M_PI_2 - 0.02, -S2.M_PI_2 + 0.01);
	S1Interval mid41 = new S1Interval(-0.01, 0.02);

	S1Interval quad2hi = new S1Interval(mid23.lo(), quad12.hi());
	S1Interval quad1lo = new S1Interval(quad12.lo(), mid41.hi());
	S1Interval quad12eps = new S1Interval(quad12.lo(), mid23.hi());
	S1Interval quadeps12 = new S1Interval(mid41.lo(), quad12.hi());
	S1Interval quad123eps = new S1Interval(quad12.lo(), mid34.hi());
	testIntervalOps(quad12, mid12, "TTTT", quad12, mid12);
	testIntervalOps(mid12, quad12, "FFTT", quad12, mid12);
	testIntervalOps(quad12, mid23, "FFTT", quad12eps, quad2hi);
	testIntervalOps(mid23, quad12, "FFTT", quad12eps, quad2hi);
	testIntervalOps(quad12, mid34, "FFFF", quad123eps, empty);
	testIntervalOps(mid34, quad12, "FFFF", quad123eps, empty);
	testIntervalOps(quad12, mid41, "FFTT", quadeps12, quad1lo);
	testIntervalOps(mid41, quad12, "FFTT", quadeps12, quad1lo);

	S1Interval quad2lo = new S1Interval(quad23.lo(), mid12.hi());
	S1Interval quad3hi = new S1Interval(mid34.lo(), quad23.hi());
	S1Interval quadeps23 = new S1Interval(mid12.lo(), quad23.hi());
	S1Interval quad23eps = new S1Interval(quad23.lo(), mid34.hi());
	S1Interval quadeps123 = new S1Interval(mid41.lo(), quad23.hi());
	testIntervalOps(quad23, mid12, "FFTT", quadeps23, quad2lo);
	testIntervalOps(mid12, quad23, "FFTT", quadeps23, quad2lo);
	testIntervalOps(quad23, mid23, "TTTT", quad23, mid23);
	testIntervalOps(mid23, quad23, "FFTT", quad23, mid23);
	testIntervalOps(quad23, mid34, "FFTT", quad23eps, quad3hi);
	testIntervalOps(mid34, quad23, "FFTT", quad23eps, quad3hi);
	testIntervalOps(quad23, mid41, "FFFF", quadeps123, empty);
	testIntervalOps(mid41, quad23, "FFFF", quadeps123, empty);

	// AddPoint()
	S1Interval r = S1Interval.empty();
	S1Interval res;
	res = r.addPoint(0);
	assertEquals(res, zero);

	res = r.addPoint(S2.M_PI);
	assertEquals(res, pi);

	res = r.addPoint(-S2.M_PI);
	assertEquals(res, mipi);

	res = r.addPoint(S2.M_PI);
	res = res.addPoint(-S2.M_PI);
	assertEquals(res, pi);

	res = res.addPoint(-S2.M_PI);
	res.addPoint(S2.M_PI);
	assertEquals(res, mipi);

	res = r.addPoint(mid12.lo());
	res = res.addPoint(mid12.hi());
	assertEquals(res, mid12);

	res = r.addPoint(mid23.lo());
	res = res.addPoint(mid23.hi());
	assertEquals(res, mid23);

	res = quad1.addPoint(-0.9 * S2.M_PI);
	res = res.addPoint(-S2.M_PI_2);
	assertEquals(res, quad123);

	r = S1Interval.full();
	res = r.addPoint(0);
	assertTrue(res.isFull());

	res = r.addPoint(S2.M_PI);
	assertTrue(res.isFull());

	res = r.addPoint(-S2.M_PI);
	assertTrue(res.isFull());

	// FromPointPair()
	assertEquals(S1Interval.fromPointPair(-S2.M_PI, S2.M_PI), pi);
	assertEquals(S1Interval.fromPointPair(S2.M_PI, -S2.M_PI), pi);
	assertEquals(S1Interval.fromPointPair(mid34.hi(), mid34.lo()), mid34);
	assertEquals(S1Interval.fromPointPair(mid23.lo(), mid23.hi()), mid23);

	// Expanded()
	assertEquals(empty.expanded(1), empty);
	assertEquals(full.expanded(1), full);
	assertEquals(zero.expanded(1), new S1Interval(-1, 1));
	assertEquals(mipi.expanded(0.01), new S1Interval(S2.M_PI - 0.01, -S2.M_PI + 0.01));
	assertEquals(pi.expanded(27), full);
	assertEquals(pi.expanded(S2.M_PI_2), quad23);
	assertEquals(pi2.expanded(S2.M_PI_2), quad12);
	assertEquals(mipi2.expanded(S2.M_PI_2), quad34);

	// ApproxEquals()
	assertTrue(empty.approxEquals(empty));
	assertTrue(zero.approxEquals(empty) && empty.approxEquals(zero));
	assertTrue(pi.approxEquals(empty) && empty.approxEquals(pi));
	assertTrue(mipi.approxEquals(empty) && empty.approxEquals(mipi));
	assertTrue(pi.approxEquals(mipi) && mipi.approxEquals(pi));
	assertTrue(pi.union(mipi).approxEquals(pi));
	assertTrue(mipi.union(pi).approxEquals(pi));
	assertTrue(pi.union(mid12).union(zero).approxEquals(quad12));
	assertTrue(quad2.intersection(quad3).approxEquals(pi));
	assertTrue(quad3.intersection(quad2).approxEquals(pi));
	}
	}