bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestAdapter.java

   1 /*******************************************************************************
   2  *  Copyright (c) 2010 Association for Decentralized Information Management in
   3  *  Industry THTH ry.
   4  *  All rights reserved. This program and the accompanying materials
   5  *  are made available under the terms of the Eclipse Public License v1.0
   6  *  which accompanies this distribution, and is available at
   7  *  http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  *  Contributors:
  10  *      VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.databoard.tests;
  13
  14 import java.util.ArrayList;
  15 import java.util.Arrays;
  16 import java.util.HashMap;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19 import java.util.TreeMap;
  20
  21 import junit.framework.TestCase;
  22
  23 import org.simantics.databoard.Bindings;
  24 import org.simantics.databoard.Datatypes;
  25 import org.simantics.databoard.adapter.AdaptException;
  26 import org.simantics.databoard.adapter.Adapter;
  27 import org.simantics.databoard.adapter.AdapterConstructionException;
  28 import org.simantics.databoard.binding.ArrayBinding;
  29 import org.simantics.databoard.binding.Binding;
  30 import org.simantics.databoard.binding.MapBinding;
  31 import org.simantics.databoard.binding.RecordBinding;
  32 import org.simantics.databoard.binding.VariantBinding;
  33 import org.simantics.databoard.binding.error.BindingConstructionException;
  34 import org.simantics.databoard.binding.impl.DoubleBindingDefault;
  35 import org.simantics.databoard.binding.impl.IntegerBindingDefault;
  36 import org.simantics.databoard.type.DoubleType;
  37 import org.simantics.databoard.type.IntegerType;
  38
  39 public class TestAdapter extends TestCase {
  40
  41
  42
  43         /////////////////////////////////////////////
  44         public static enum FooEnum {Ford, Volvo, Audi, Mazda, Nissan, Honda, Toyota, BMW, MercedezBenz}
  45         public static enum BarEnum {Audi, BMW, MercedezBenz}
  46
  47         public void testUnionAdaption() throws Exception
  48         {
  49                 Binding fooB = Bindings.getBinding( FooEnum.class );
  50                 Binding barB = Bindings.getBinding( BarEnum.class );
  51
  52                 assertEquals( FooEnum.Audi, Bindings.adapt( BarEnum.Audi, barB, fooB ) );
  53                 assertEquals( FooEnum.MercedezBenz, Bindings.adapt( BarEnum.MercedezBenz, barB, fooB ) );
  54                 assertEquals( FooEnum.BMW, Bindings.adapt( BarEnum.BMW, barB, fooB ) );
  55
  56                 // Fail-Test, We shouldn't be able to convert from Foo to Bar (from super-type to sub-type)
  57                 try {
  58                         assertEquals( BarEnum.BMW, Bindings.adapt( FooEnum.BMW, fooB, barB ) );
  59                         fail();
  60                 } catch (AdaptException e) {}
  61         }
  62         /////////////////////////////////////////////
  63
  64         /////////////////////////////////////////////
  65         public static class Foo2 {
  66                 public double x, y, z;
  67         }
  68
  69         public static class Bar2 {
  70                 public int id;
  71                 public float y, z, x;
  72         }
  73
  74         public void testRecordAdaption() throws Exception
  75         {
  76                 Binding fooB = Bindings.getBinding( Foo2.class );
  77                 Binding barB = Bindings.getBinding( Bar2.class );
  78                 Bar2 bar = new Bar2();
  79                 bar.id = 5;
  80                 bar.x = 5.0f;
  81                 bar.y = 7.0f;
  82                 bar.z = 123.43243244242423f;
  83
  84                 Foo2 foo = (Foo2) Bindings.adapt(bar, barB, fooB);
  85                 assertEquals(bar.x, (float) foo.x);
  86                 assertEquals(bar.y, (float) foo.y);
  87                 assertEquals(bar.z, (float) foo.z);
  88
  89                 // Fail-Test, Cannot convert Bar2 to Foo2 because there is Id field
  90                 // No longer fails for missing fields after r30952 (02/19/15, Niemistö)
  91                 /*
  92                 try {
  93                         Bindings.adapt(foo, fooB, barB);
  94                         fail();
  95
  96                 } catch (AdaptException e) {
  97                 }
  98                 */
  99         }
 100         /////////////////////////////////////////////
 101
 102
 103
 104         public void testPrimitiveAdaptation() throws AdaptException, BindingConstructionException
 105         {
 106                 try {
 107                         Adapter int2Double = Bindings.getAdapter(Bindings.getBinding(int.class), Bindings.getBinding(double.class));
 108                         fail("Exception excepted");
 109                 } catch (AdapterConstructionException e) {
 110                 }
 111
 112                 try {
 113                         Adapter double2Double = Bindings.getAdapter(Bindings.getBinding(double.class), Bindings.getBinding(double.class));
 114                         assertEquals(5.0, double2Double.adapt(5.0));
 115
 116                         Adapter int2Double = Bindings.getTypeAdapter(Bindings.getBinding(int.class), Bindings.getBinding(double.class));
 117                         assertEquals(5.0, int2Double.adapt(5));
 118                 } catch (AdapterConstructionException e) {
 119                         fail("Exception unexcepted");
 120                 }
 121
 122                 try {
 123                         Adapter doubleArray2intArray = Bindings.getAdapter(Bindings.getBinding(double[].class), Bindings.getBinding(int[].class));
 124                         assertEquals(new double[] {5.0, 6.0, 7.0}, doubleArray2intArray.adapt(new int[] {5, 6, 7}));
 125                         fail("Exception excepted");
 126                 } catch (AdapterConstructionException e) {
 127                 }
 128
 129                 try {
 130                         Adapter doubleArray2intArray = Bindings.getTypeAdapter(Bindings.getBinding(double[].class), Bindings.getBinding(int[].class));
 131                         assertTrue( Arrays.equals( new int[] {5, 6, 7}, (int[]) doubleArray2intArray.adapt(new double[] {5.0, 6.0, 7.0})) );
 132                 } catch (AdapterConstructionException e) {
 133                         fail("Exception unexcepted");
 134                 }
 135
 136                 try {
 137                         Adapter doubleArray2intArray = Bindings.getTypeAdapter(Bindings.getBinding(Double[].class), Bindings.getBinding(int[].class));
 138                         assertTrue( Arrays.equals( new int[] {5, 6, 7}, (int[]) doubleArray2intArray.adapt(new Double[] {5.0, 6.0, 7.0})) );
 139                 } catch (AdapterConstructionException e) {
 140                         fail("Exception unexcepted");
 141                 }
 142
 143
 144         }
 145
 146         public void testUnitAdaptation() throws AdaptException
 147         {
 148                 try {
 149                         Adapter hours2Seconds = Bindings.getAdapter(new DoubleBindingDefault(new DoubleType("h")), new DoubleBindingDefault(new DoubleType("s")));
 150                         assertEquals(3600.0, hours2Seconds.adapt(1.0));
 151                 } catch (AdapterConstructionException e) {
 152                         fail("Exception unexcepted");
 153                 }
 154
 155                 try {
 156                         Adapter m2ft = Bindings.getAdapter(new DoubleBindingDefault(new DoubleType("m")), new DoubleBindingDefault(new DoubleType("ft")));
 157                         assertTrue( Math.abs( ( (Double) m2ft.adapt(1.524) ) - 5.0 ) < 0.1 );
 158                 } catch (AdapterConstructionException e) {
 159                         fail("Exception unexcepted");
 160                 }
 161
 162                 try {
 163                         Adapter hours2Seconds = Bindings.getAdapter(new IntegerBindingDefault(new IntegerType("h")), new IntegerBindingDefault(new IntegerType("s")));
 164                         assertEquals(3600, hours2Seconds.adapt(1));
 165                 } catch (AdapterConstructionException e) {
 166                         fail("Exception unexcepted");
 167                 }
 168
 169                 try {
 170                         Integer hours = 1;
 171                         Double seconds = (Double) Bindings.adapt(hours, new IntegerBindingDefault(new IntegerType("h")), new DoubleBindingDefault(new DoubleType("s")));
 172                         assertEquals(3600.0, seconds);
 173                 } catch (AdaptException e) {
 174                         fail("Exception unexcepted");
 175                 }
 176
 177         }
 178
 179         public static class Foo {
 180                 List<String> list;
 181                 String[] array;
 182                 LinkedList<String> linkedList;
 183                 HashMap<Integer, String> hashMap;
 184                 TreeMap<Integer, String> treeMap;
 185         }
 186
 187         @SuppressWarnings("unchecked")
 188         public void testListAdaption() throws Exception
 189         {
 190                 RecordBinding fooBinding  = (RecordBinding) Bindings.getBinding(Foo.class);
 191                 ArrayBinding listBinding  = (ArrayBinding) fooBinding.getComponentBindings()[0];
 192                 ArrayBinding arrayBinding = (ArrayBinding) fooBinding.getComponentBindings()[1];
 193                 ArrayBinding linkedListBinding = (ArrayBinding) fooBinding.getComponentBindings()[2];
 194                 Adapter list2array = Bindings.getAdapter(listBinding, arrayBinding);
 195                 Adapter array2linkedList = Bindings.getAdapter(arrayBinding, linkedListBinding);
 196                 Foo foo = new Foo();
 197                 foo.list = new ArrayList<String>();
 198                 foo.list.add("XYZ");
 199                 foo.array = (String[]) list2array.adapt(foo.list);
 200                 foo.linkedList = (LinkedList<String>) array2linkedList.adapt(foo.array);
 201                 assertEquals(foo.array[0], foo.list.get(0));
 202                 assertEquals(foo.list, foo.linkedList);
 203
 204                 assertEquals( listBinding.hashValue(foo.list), arrayBinding.hashValue(foo.array) );
 205                 assertEquals( listBinding.hashValue(foo.list), linkedListBinding.hashValue(foo.linkedList) );
 206         }
 207
 208         @SuppressWarnings("unchecked")
 209         public void testMapAdaption() throws Exception
 210         {
 211                 RecordBinding fooBinding  = (RecordBinding) Bindings.getBinding(Foo.class);
 212                 MapBinding hashMapBinding = (MapBinding) fooBinding.getComponentBindings()[3];
 213                 MapBinding treeMapBinding = (MapBinding) fooBinding.getComponentBindings()[4];
 214                 Adapter list2array = Bindings.getAdapter(hashMapBinding, treeMapBinding);
 215                 Foo foo = new Foo();
 216                 foo.hashMap = new HashMap<Integer, String>();
 217                 foo.hashMap.put(500, "Indy-500");
 218                 foo.treeMap = (TreeMap<Integer, String>) list2array.adapt(foo.hashMap);
 219                 assertEquals(foo.hashMap, foo.treeMap);
 220         }
 221
 222         public void testVariantAdaption() throws Exception
 223         {
 224                 VariantBinding variantBinding  = (VariantBinding) Bindings.getBinding(Object.class);
 225                 VariantBinding variant2Binding = (VariantBinding) Bindings.getMutableBinding(Datatypes.VARIANT);
 226
 227                 Adapter obj2variant = Bindings.getAdapter(variantBinding, variant2Binding);
 228                 Object genericVariant = obj2variant.adapt( "blondi" );
 229                 System.out.println(genericVariant);
 230         }
 231
 232
 233
 234 }
 235