@Override
 protected List<ApplicationFeatureViewModel> getObjectsWithDifferentValue() {
   return Arrays.asList(
       pkg(ApplicationFeatureId.newPackage("com.mycompany")),
       cls(ApplicationFeatureId.newClass("com.mycompany.Foo")),
       prop(ApplicationFeatureId.newMember("com.mycompany.Foo#bar2")));
 }
    @Test
    public void givenPackage_whenAddPackageAndClass() throws Exception {

      // given
      final ApplicationFeatureId applicationFeatureId =
          ApplicationFeatureId.newPackage("com.mycompany");
      final ApplicationFeatureId packageFeatureId =
          ApplicationFeatureId.newPackage("com.mycompany.flob");
      final ApplicationFeatureId classFeatureId =
          ApplicationFeatureId.newClass("com.mycompany.Bar");

      final ApplicationFeature applicationFeature = new ApplicationFeature(applicationFeatureId);

      applicationFeature.addToContents(packageFeatureId);
      applicationFeature.addToContents(classFeatureId);

      ApplicationPackage applicationFeatureVM = new ApplicationPackage(applicationFeatureId);
      applicationFeatureVM.applicationFeatureRepository = mockApplicationFeatureRepository;
      applicationFeatureVM.container = mockContainer;

      // then
      context.checking(
          new Expectations() {
            {
              allowing(mockApplicationFeatureRepository).findFeature(applicationFeatureId);
              will(returnValue(applicationFeature));

              oneOf(mockContainer)
                  .newViewModelInstance(
                      ApplicationPackage.class, packageFeatureId.asEncodedString());
              will(returnValue(new ApplicationPackage()));

              oneOf(mockContainer)
                  .newViewModelInstance(ApplicationClass.class, classFeatureId.asEncodedString());
              will(returnValue(new ApplicationClass()));
            }
          });

      // when
      final List<ApplicationFeatureViewModel> contents = applicationFeatureVM.getContents();

      // then
      assertThat(contents.size(), is(2));
    }
    // should this instead fail-fast, given that the parent should always exist if the child does?
    @Test
    public void whenParentNonExistent() throws Exception {

      // given
      final ApplicationFeatureId featureId = ApplicationFeatureId.newPackage("com.mycompany");
      final ApplicationFeatureId parentId = ApplicationFeatureId.newPackage("com");
      applicationFeatureViewModel.setFeatureId(featureId);

      // then
      context.checking(
          new Expectations() {
            {
              allowing(mockApplicationFeatureRepository).findFeature(parentId);
              will(returnValue(null));

              never(mockContainer);
            }
          });

      // when
      assertThat(applicationFeatureViewModel.getParent(), is(nullValue()));
    }
    @Test
    public void whenPackage() throws Exception {
      ApplicationPackage applicationPackage =
          new ApplicationPackage(ApplicationFeatureId.newPackage("com.mycompany"));

      final String str = applicationPackage.viewModelMemento();
      final ApplicationFeatureViewModel applicationFeatureVM2 = new ApplicationPackage();
      applicationFeatureVM2.viewModelInit(str);

      assertThat(applicationFeatureVM2.getType(), CoreMatchers.is(ApplicationFeatureType.PACKAGE));
      assertThat(applicationFeatureVM2.getPackageName(), is("com.mycompany"));
      assertThat(applicationFeatureVM2.getClassName(), is(nullValue()));
      assertThat(applicationFeatureVM2.getMemberName(), is(nullValue()));
    }
    @Test
    public void whenPackage() throws Exception {

      // given
      final ApplicationFeatureId featureId = ApplicationFeatureId.newPackage("com.mycompany");
      final ApplicationFeatureId parentId = ApplicationFeatureId.newPackage("com");
      applicationFeatureViewModel.setFeatureId(featureId);

      // then
      context.checking(
          new Expectations() {
            {
              allowing(mockApplicationFeatureRepository).findFeature(parentId);
              will(returnValue(mockApplicationFeature));

              oneOf(mockContainer)
                  .newViewModelInstance(ApplicationPackage.class, parentId.asEncodedString());
              will(returnValue(parent));
            }
          });

      // when
      assertThat(applicationFeatureViewModel.getParent(), is(parent));
    }
    @Test
    public void whenPackageTopLevel() throws Exception {

      // given
      final ApplicationFeatureId featureId = ApplicationFeatureId.newPackage("com");
      applicationFeatureViewModel.setFeatureId(featureId);

      // then
      context.checking(
          new Expectations() {
            {
              never(mockApplicationFeatureRepository);

              never(mockContainer);
            }
          });

      // when
      assertThat(applicationFeatureViewModel.getParent(), is(nullValue()));
    }
 @Test
 public void whenPackage() throws Exception {
   applicationFeatureViewModel =
       new ApplicationFeatureViewModel(ApplicationFeatureId.newPackage("com.mycompany")) {};
   assertThat(applicationFeatureViewModel.hideContributed(), is(true));
 }
 @Test
 public void whenPackage() throws Exception {
   applicationFeatureViewModel =
       new ApplicationFeatureViewModel(ApplicationFeatureId.newPackage("com.mycompany")) {};
   assertThat(applicationFeatureViewModel.getType(), is(ApplicationFeatureType.PACKAGE));
 }
 @Override
 protected List<ApplicationFeatureViewModel> getObjectsWithSameValue() {
   return Arrays.asList(
       pkg(ApplicationFeatureId.newPackage("com.mycompany")),
       pkg(ApplicationFeatureId.newPackage("com.mycompany")));
 }