package com.lexicalscope.fluentreflection.bean.endtoend;
   
   import static ch.lambdaj.Lambda.selectFirst;
   import static com.lexicalscope.fluentreflection.bean.BeanMap.map;
   import static com.lexicalscope.fluentreflection.bean.endtoend.MapEntryMatcher.mapEntry;
   import static org.hamcrest.MatcherAssert.assertThat;
   import static org.hamcrest.Matchers.*;
   
   import java.util.HashMap;
  import java.util.Map;
  
  import org.junit.Test;
  
  /*
   * Copyright 2011 Tim Wood
   *
   * 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. 
   */
  
  public class TestBeanMap {
      static class Bean {
          private int readWriteProperty;
          private String readOnlyProperty;
          private Object writeOnlyProperty;
  
          String getReadOnlyProperty() {
              return readOnlyProperty;
          }
  
          int getReadWriteProperty() {
              return readWriteProperty;
          }
  
          void setReadWriteProperty(final int readWriteProperty) {
              this.readWriteProperty = readWriteProperty;
          }
  
          void setWriteOnlyProperty(final Object writeOnlyProperty) {
              this.writeOnlyProperty = writeOnlyProperty;
          }
      }
  
      private final Bean bean = new Bean();
      private final Map<String, Object> map = map(bean);
  
      @Test(expected = IllegalArgumentException.class) public void putNonExistentPropertyCausesException() {
          map.put("notAProperty", "anything");
      }
  
      @Test public void getNonExistentPropertyGivesNull() {
          assertThat(map.get("notAProperty"), equalTo(null));
      }
  
      @Test public void propertyIsPresent() {
          assertThat(map.containsKey("readWriteProperty"), equalTo(true));
      }
  
      @Test public void initalValueOfPropertyIsZero() {
          assertThat(map.get("readWriteProperty"), equalTo((Object) 0));
      }
  
      @Test public void settingValueOfPropertyUpdatesObject() {
          assertThat(map.put("readWriteProperty", 14), equalTo((Object) 0));
          assertThat(bean.getReadWriteProperty(), equalTo(14));
      }
  
      @Test public void settingValueOfObjectUpdatesMap() {
          bean.setReadWriteProperty(14);
          assertThat(map.get("readWriteProperty"), equalTo((Object) 14));
      }
  
      @Test public void settingValueOfMapReturnsOldValue() {
          bean.setReadWriteProperty(14);
          assertThat(map.put("readWriteProperty", 15), equalTo((Object) 14));
      }
  
      @Test public void readOnlyPropertyIsPresent() {
          assertThat(map.containsKey("readOnlyProperty"), equalTo(true));
      }
  
      @Test public void initalValueOfReadOnlyPropertyIsNull() {
          assertThat(map.get("readOnlyProperty"), equalTo((Object) null));
      }
  
      @Test public void settingValueOfReadOnlyPropertyIsIgnoredByObject() {
          assertThat(map.put("readOnlyProperty", "14"), equalTo((Object) null));
          assertThat(bean.getReadOnlyProperty(), equalTo(null));
      }
  
     @Test public void changesToReadOnlyPropertyAreReturnedByMap() {
         bean.readOnlyProperty = "new value";
         assertThat(map.get("readOnlyProperty"), equalTo((Object) "new value"));
     }
 
     @Test public void settingValueOfReadOnlyPropertyInMapReturnsOldValue() {
         bean.readOnlyProperty = "old value";
         assertThat(map.put("readOnlyProperty", "new value"), equalTo((Object) "old value"));
     }
 
     @Test public void writeOnlyPropertyIsPresent() {
         assertThat(map.containsKey("writeOnlyProperty"), equalTo(true));
     }
 
     @Test public void initalValueOfWriteOnlyPropertyIsNull() {
         assertThat(map.get("writeOnlyProperty"), equalTo((Object) null));
     }
 
     @Test public void settingValueOfWriteOnlyPropertyUpdatesObject() {
         assertThat(map.put("writeOnlyProperty", "new value"), equalTo((Object) null));
         assertThat(bean.writeOnlyProperty, equalTo((Object) "new value"));
     }
 
     @Test public void changesToWriteOnlyPropertyAreIgnoredByMap() {
         bean.setWriteOnlyProperty("new value");
         assertThat(map.get("writeOnlyProperty"), equalTo((Object) null));
     }
 
     @Test public void settingValueOfWriteOnlyPropertyInMapReturnsNullValue() {
         bean.setWriteOnlyProperty("old value");
         assertThat(map.put("writeOnlyProperty", "new value"), equalTo((Object) null));
     }
 
     @Test(expected = UnsupportedOperationException.class) public void clearIsUnsupported() {
         map.clear();
     }
 
     @Test(expected = UnsupportedOperationException.class) public void removeIsUnsupported() {
         map.remove("writeOnlyProperty");
     }
 
     @Test public void containsInitialReadableValues() {
         assertThat(map.containsValue(0), equalTo(true));
         assertThat(map.containsValue(null), equalTo(true));
     }
 
     @Test public void containsChangedReadableValues() {
         bean.setReadWriteProperty(14);
         assertThat(map.containsValue(14), equalTo(true));
         assertThat(map.containsValue(0), equalTo(false));
     }
 
     @Test public void doesNotContainsWriteOnlyValues() {
         bean.setWriteOnlyProperty("myValue");
         assertThat(map.containsValue("myValue"), equalTo(false));
     }
 
     @Test public void valuesContainsAllValues() {
         bean.setReadWriteProperty(14);
         bean.readOnlyProperty = "my value";
         assertThat(map.values(), containsInAnyOrder((Object) 14, "my value", null));
     }
 
     @Test public void keySetContainsAllProperties() {
         assertThat(map.keySet(), containsInAnyOrder("readWriteProperty", "readOnlyProperty", "writeOnlyProperty"));
     }
 
     @Test public void beanWithPropertiesGivesNotEmptyMap() {
         assertThat(map.isEmpty(), equalTo(false));
     }
 
     @Test public void beanWithoutPropertiesGivesNotEmptyMap() {
         class EmptyBean {}
         assertThat(map(new EmptyBean()).isEmpty(), equalTo(true));
     }
 
     @Test public void beanWithPropertiesHasCorrectSize() {
         assertThat(map.size(), equalTo(3));
     }
 
     @Test public void beanWithoutPropertiesHasZeroSize() {
         class EmptyBean {}
         assertThat(map(new EmptyBean()).size(), equalTo(0));
     }
 
     @Test public void putAllUpdatesWritableProperties() {
         final Map<String, Object> newMap = new HashMap<String, Object>();
         newMap.put("readWriteProperty", 14);
         newMap.put("writeOnlyProperty", "My Value");
 
         map.putAll(newMap);
 
         assertThat(bean.getReadWriteProperty(), equalTo(14));
         assertThat(bean.writeOnlyProperty, equalTo((Object) "My Value"));
     }
 
     @Test public void putAllIgnoresReadOnlyProperties() {
         final Map<String, Object> newMap = new HashMap<String, Object>();
         newMap.put("readOnlyProperty", "My Value");
 
         map.putAll(newMap);
 
         assertThat(bean.getReadOnlyProperty(), equalTo(null));
     }
 
     @Test(expected = IllegalArgumentException.class) public void putAllWithNonExistentPropertyThrowsException() {
         final Map<String, Object> newMap = new HashMap<String, Object>();
         newMap.put("notAProperty", 14);
 
         map.putAll(newMap);
     }
 
     @Test public void entrySetContainsAllPropertiesAndReadableValues() {
         bean.setReadWriteProperty(14);
         bean.readOnlyProperty = "my value";
         assertThat(map.entrySet(), hasItem(mapEntry("readWriteProperty", (Object) 14)));
         assertThat(map.entrySet(), hasItem(mapEntry("readOnlyProperty", (Object) "my value")));
     }
 
     @Test public void entrySetAllowsValuesToBeChanged() {
         final Map.Entry<String, Object> entry = selectFirst(map.entrySet(), mapEntry("readWriteProperty"));
         entry.setValue(14);
         assertThat(bean.getReadWriteProperty(), equalTo(14));
     }
 
     @Test(expected = UnsupportedOperationException.class) public void cannotRemoveFromKeySet() {
         map.keySet().remove("readWriteProperty");
     }
 
     @Test(expected = UnsupportedOperationException.class) public void cannotRemoveFromKeySetIterator() {
         map.keySet().iterator().remove();
     }
 
     @Test(expected = UnsupportedOperationException.class) public void cannotRemoveFromEntrySet() {
         map.entrySet().remove(map.entrySet().iterator().next());
     }
 
     @Test(expected = UnsupportedOperationException.class) public void cannotRemoveFromEntrySetIterator() {
         map.entrySet().iterator().remove();
     }
 }