| /* $Id$ |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.apache.etch.bindings.java.support; |
| |
| import java.lang.reflect.Array; |
| import java.util.Date; |
| |
| import org.apache.etch.bindings.java.msg.Validator; |
| import org.junit.Assert; |
| import org.junit.Test; |
| |
| |
| /** Tests various validators */ |
| public class TestValidators |
| { |
| /** @throws Exception */ |
| @Test |
| public void test_boolean() throws Exception |
| { |
| test( Validator_boolean.get( 2 ), 2, |
| new boolean[][] { { false, false }, { false, false } } ); |
| |
| test( Validator_boolean.get( 2 ), 2, |
| new boolean[][] { { true, true }, { true, true } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_byte() throws Exception |
| { |
| test( Validator_byte.get( 2 ), 2, |
| new byte[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_byte.get( 2 ), 2, |
| new byte[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_byte.get( 2 ), 2, |
| new byte[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_byte.get( 2 ), 2, |
| new byte[][] { { Byte.MAX_VALUE, Byte.MAX_VALUE }, { Byte.MAX_VALUE, Byte.MAX_VALUE } } ); |
| |
| test( Validator_byte.get( 2 ), 2, |
| new byte[][] { { Byte.MIN_VALUE, Byte.MIN_VALUE }, { Byte.MIN_VALUE, Byte.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_short() throws Exception |
| { |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { Byte.MAX_VALUE, Byte.MAX_VALUE }, { Byte.MAX_VALUE, Byte.MAX_VALUE } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { Byte.MIN_VALUE, Byte.MIN_VALUE }, { Byte.MIN_VALUE, Byte.MIN_VALUE } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { Short.MAX_VALUE, Short.MAX_VALUE }, { Short.MAX_VALUE, Short.MAX_VALUE } } ); |
| |
| test( Validator_short.get( 2 ), 2, |
| new short[][] { { Short.MIN_VALUE, Short.MIN_VALUE }, { Short.MIN_VALUE, Short.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_int() throws Exception |
| { |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Byte.MAX_VALUE, Byte.MAX_VALUE }, { Byte.MAX_VALUE, Byte.MAX_VALUE } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Byte.MIN_VALUE, Byte.MIN_VALUE }, { Byte.MIN_VALUE, Byte.MIN_VALUE } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Short.MAX_VALUE, Short.MAX_VALUE }, { Short.MAX_VALUE, Short.MAX_VALUE } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Short.MIN_VALUE, Short.MIN_VALUE }, { Short.MIN_VALUE, Short.MIN_VALUE } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Integer.MAX_VALUE, Integer.MAX_VALUE }, { Integer.MAX_VALUE, Integer.MAX_VALUE } } ); |
| |
| test( Validator_int.get( 2 ), 2, |
| new int[][] { { Integer.MIN_VALUE, Integer.MIN_VALUE }, { Integer.MIN_VALUE, Integer.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_long() throws Exception |
| { |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Byte.MAX_VALUE, Byte.MAX_VALUE }, { Byte.MAX_VALUE, Byte.MAX_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Byte.MIN_VALUE, Byte.MIN_VALUE }, { Byte.MIN_VALUE, Byte.MIN_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Short.MAX_VALUE, Short.MAX_VALUE }, { Short.MAX_VALUE, Short.MAX_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Short.MIN_VALUE, Short.MIN_VALUE }, { Short.MIN_VALUE, Short.MIN_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Integer.MAX_VALUE, Integer.MAX_VALUE }, { Integer.MAX_VALUE, Integer.MAX_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Integer.MIN_VALUE, Integer.MIN_VALUE }, { Integer.MIN_VALUE, Integer.MIN_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Long.MAX_VALUE, Long.MAX_VALUE }, { Long.MAX_VALUE, Long.MAX_VALUE } } ); |
| |
| test( Validator_long.get( 2 ), 2, |
| new long[][] { { Long.MIN_VALUE, Long.MIN_VALUE }, { Long.MIN_VALUE, Long.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_float() throws Exception |
| { |
| test( Validator_float.get( 2 ), 2, |
| new float[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_float.get( 2 ), 2, |
| new float[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_float.get( 2 ), 2, |
| new float[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_float.get( 2 ), 2, |
| new float[][] { { Float.MAX_VALUE, Float.MAX_VALUE }, { Float.MAX_VALUE, Float.MAX_VALUE } } ); |
| |
| test( Validator_float.get( 2 ), 2, |
| new float[][] { { Float.MIN_VALUE, Float.MIN_VALUE }, { Float.MIN_VALUE, Float.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_double() throws Exception |
| { |
| test( Validator_double.get( 2 ), 2, |
| new double[][] { { 0, 0 }, { 0, 0 } } ); |
| |
| test( Validator_double.get( 2 ), 2, |
| new double[][] { { 1, 1 }, { 1, 1 } } ); |
| |
| test( Validator_double.get( 2 ), 2, |
| new double[][] { { -1, -1 }, { -1, -1 } } ); |
| |
| test( Validator_double.get( 2 ), 2, |
| new double[][] { { Double.MAX_VALUE, Double.MAX_VALUE }, { Double.MAX_VALUE, Double.MAX_VALUE } } ); |
| |
| test( Validator_double.get( 2 ), 2, |
| new double[][] { { Double.MIN_VALUE, Double.MIN_VALUE }, { Double.MIN_VALUE, Double.MIN_VALUE } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_string() throws Exception |
| { |
| test( Validator_string.get( 2 ), 2, |
| new String[][] { { "", "" }, { "", "" } } ); |
| |
| test( Validator_string.get( 2 ), 2, |
| new String[][] { { "abc", "abc" }, { "abc", "abc" } } ); |
| } |
| |
| /** @throws Exception */ |
| @Test |
| public void test_custom() throws Exception |
| { |
| test( Validator_custom.get( Date.class, 2, false ), 2, |
| new Date[][] { { new Date(), new Date() }, { new Date(), new Date() } } ); |
| } |
| |
| private void test( Validator v, int n, Object o ) |
| { |
| // System.out.printf( "testing with %s\n", v ); |
| // Assert.assertEquals( n, v.getDim() ); |
| |
| Assert.assertTrue( v.validate( o ) ); |
| |
| if (n > 0) |
| { |
| |
| |
| int k = Array.getLength( o ); |
| for (int i = 0; i < k; i++) |
| test( v.elementValidator(), n-1, Array.get( o, i ) ); |
| } |
| } |
| } |