Example usage for com.google.common.collect ImmutableMap get

List of usage examples for com.google.common.collect ImmutableMap get

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. ImmutableMap
  6. get

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableMap get.

Prototype

V get(Object key);

Source Link

Document

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

Usage

From source file:retroweibo.processor.RetroWeiboProcessor.java

private void defineVarsForType(TypeElement type, RetroWeiboTemplateVars vars) {
    Types typeUtils = processingEnv.getTypeUtils();
    List<ExecutableElement> methods = new ArrayList<ExecutableElement>();
    findLocalAndInheritedMethods(type, methods);
    determineObjectMethodsToGenerate(methods, vars);
    ImmutableSet<ExecutableElement> methodsToImplement = methodsToImplement(methods);
    Set<TypeMirror> types = new TypeMirrorSet();
    types.addAll(returnTypesOf(methodsToImplement));
    //    TypeMirror javaxAnnotationGenerated = getTypeMirror(Generated.class);
    //    types.add(javaxAnnotationGenerated);
    TypeMirror javaUtilArrays = getTypeMirror(Arrays.class);
    if (containsArrayType(types)) {
        // If there are array properties then we will be referencing java.util.Arrays.
        // Arrange to import it unless that would introduce ambiguity.
        types.add(javaUtilArrays);/*  ww  w. j a  v a 2s . c  o  m*/
    }
    BuilderSpec builderSpec = new BuilderSpec(type, processingEnv, errorReporter);
    Optional<BuilderSpec.Builder> builder = builderSpec.getBuilder();
    ImmutableSet<ExecutableElement> toBuilderMethods;
    if (builder.isPresent()) {
        types.add(getTypeMirror(BitSet.class));
        toBuilderMethods = builder.get().toBuilderMethods(typeUtils, methodsToImplement);
    } else {
        toBuilderMethods = ImmutableSet.of();
    }
    vars.toBuilderMethods = FluentIterable.from(toBuilderMethods).transform(SimpleNameFunction.INSTANCE)
            .toList();
    Set<ExecutableElement> propertyMethods = Sets.difference(methodsToImplement, toBuilderMethods);
    String pkg = TypeSimplifier.packageNameOf(type);
    TypeSimplifier typeSimplifier = new TypeSimplifier(typeUtils, pkg, types, type.asType());
    vars.imports = typeSimplifier.typesToImport();
    //    vars.generated = typeSimplifier.simplify(javaxAnnotationGenerated);
    vars.arrays = typeSimplifier.simplify(javaUtilArrays);
    vars.bitSet = typeSimplifier.simplifyRaw(getTypeMirror(BitSet.class));
    ImmutableMap<ExecutableElement, String> methodToPropertyName = methodToPropertyNameMap(propertyMethods);
    Map<ExecutableElement, String> methodToIdentifier = Maps.newLinkedHashMap(methodToPropertyName);
    fixReservedIdentifiers(methodToIdentifier);
    List<Property> props = new ArrayList<Property>();
    for (ExecutableElement method : propertyMethods) {
        String propertyType = typeSimplifier.simplify(method.getReturnType());
        String propertyName = methodToPropertyName.get(method);
        String identifier = methodToIdentifier.get(method);
        List<String> args = new ArrayList<String>();
        props.add(new Property(propertyName, identifier, method, propertyType, typeSimplifier, processingEnv));
    }
    // If we are running from Eclipse, undo the work of its compiler which sorts methods.
    eclipseHack().reorderProperties(props);
    vars.props = props;
    vars.serialVersionUID = getSerialVersionUID(type);
    vars.formalTypes = typeSimplifier.formalTypeParametersString(type);
    vars.actualTypes = TypeSimplifier.actualTypeParametersString(type);
    vars.wildcardTypes = wildcardTypeParametersString(type);

    TypeElement parcelable = processingEnv.getElementUtils().getTypeElement("android.os.Parcelable");
    vars.parcelable = parcelable != null
            && processingEnv.getTypeUtils().isAssignable(type.asType(), parcelable.asType());
    // Check for @RetroWeibo.Builder and add appropriate variables if it is present.
    if (builder.isPresent()) {
        builder.get().defineVars(vars, typeSimplifier, methodToPropertyName);
    }
}

From source file:com.facebook.buck.jvm.java.intellij.IjModuleGraph.java

/**
 * @param projectConfig the project config used
 * @param targetGraph input graph.//from   w  w  w  . ja v  a 2  s.co  m
 * @param libraryFactory library factory.
 * @param moduleFactory module factory.
 * @param aggregationMode module aggregation mode.
 * @return module graph corresponding to the supplied {@link TargetGraph}. Multiple targets from
 * the same base path are mapped to a single module, therefore an IjModuleGraph edge
 * exists between two modules (Ma, Mb) if a TargetGraph edge existed between a pair of
 * nodes (Ta, Tb) and Ma contains Ta and Mb contains Tb.
 */
public static IjModuleGraph from(final IjProjectConfig projectConfig, final TargetGraph targetGraph,
        final IjLibraryFactory libraryFactory, final IjModuleFactory moduleFactory,
        AggregationMode aggregationMode) {
    final ImmutableMap<BuildTarget, IjModule> rulesToModules = createModules(projectConfig, targetGraph,
            moduleFactory, aggregationMode.getGraphMinimumDepth(targetGraph.getNodes().size()));
    final ExportedDepsClosureResolver exportedDepsClosureResolver = new ExportedDepsClosureResolver(
            targetGraph);
    ImmutableMap.Builder<IjProjectElement, ImmutableMap<IjProjectElement, DependencyType>> depsBuilder = ImmutableMap
            .builder();
    final Set<IjLibrary> referencedLibraries = new HashSet<>();

    for (final IjModule module : ImmutableSet.copyOf(rulesToModules.values())) {
        Map<IjProjectElement, DependencyType> moduleDeps = new HashMap<>();

        for (Map.Entry<BuildTarget, DependencyType> entry : module.getDependencies().entrySet()) {
            BuildTarget depBuildTarget = entry.getKey();
            DependencyType depType = entry.getValue();
            ImmutableSet<IjProjectElement> depElements;

            if (depType.equals(DependencyType.COMPILED_SHADOW)) {
                TargetNode<?, ?> targetNode = targetGraph.get(depBuildTarget);
                Optional<IjLibrary> library = libraryFactory.getLibrary(targetNode);
                if (library.isPresent()) {
                    depElements = ImmutableSet.of(library.get());
                } else {
                    depElements = ImmutableSet.of();
                }
            } else {
                depElements = Stream
                        .concat(exportedDepsClosureResolver.getExportedDepsClosure(depBuildTarget).stream(),
                                Stream.of(depBuildTarget))
                        .filter(input -> {
                            // The exported deps closure can contain references back to targets contained
                            // in the module, so filter those out.
                            TargetNode<?, ?> targetNode = targetGraph.get(input);
                            return !module.getTargets().contains(targetNode);
                        }).map(depTarget -> {
                            IjModule depModule = rulesToModules.get(depTarget);
                            if (depModule != null) {
                                return depModule;
                            }
                            TargetNode<?, ?> targetNode = targetGraph.get(depTarget);
                            return libraryFactory.getLibrary(targetNode).orElse(null);
                        }).filter(Objects::nonNull).collect(MoreCollectors.toImmutableSet());
            }

            for (IjProjectElement depElement : depElements) {
                Preconditions.checkState(!depElement.equals(module));
                DependencyType.putWithMerge(moduleDeps, depElement, depType);
            }
        }

        if (!module.getExtraClassPathDependencies().isEmpty()) {
            IjLibrary extraClassPathLibrary = IjLibrary.builder()
                    .setClassPaths(module.getExtraClassPathDependencies()).setTargets(ImmutableSet.of())
                    .setName("library_" + module.getName() + "_extra_classpath").build();
            moduleDeps.put(extraClassPathLibrary, DependencyType.PROD);
        }

        moduleDeps.keySet().stream().filter(dep -> dep instanceof IjLibrary).map(library -> (IjLibrary) library)
                .forEach(referencedLibraries::add);

        depsBuilder.put(module, ImmutableMap.copyOf(moduleDeps));
    }

    referencedLibraries.forEach(library -> depsBuilder.put(library, ImmutableMap.of()));

    return new IjModuleGraph(depsBuilder.build());
}

From source file:com.google.gerrit.metrics.dropwizard.MetricJson.java

private void init(Metric metric, ImmutableMap<String, String> atts) {
    if (metric instanceof BucketedMetric) {
        BucketedMetric m = (BucketedMetric) metric;
        if (m.getTotal() != null) {
            init(m.getTotal(), atts);/*  w w  w. ja  v  a2 s . c  o m*/
        }

        Field<?>[] fieldList = m.getFields();
        fields = new ArrayList<>(fieldList.length);
        for (Field<?> f : fieldList) {
            fields.add(new FieldJson(f));
        }
        buckets = makeBuckets(fieldList, m.getCells(), atts);

    } else if (metric instanceof Counter) {
        Counter c = (Counter) metric;
        count = c.getCount();

    } else if (metric instanceof Gauge) {
        Gauge<?> g = (Gauge<?>) metric;
        value = g.getValue();

    } else if (metric instanceof Meter) {
        Meter m = (Meter) metric;
        count = m.getCount();
        rate_1m = m.getOneMinuteRate();
        rate_5m = m.getFiveMinuteRate();
        rate_15m = m.getFifteenMinuteRate();

    } else if (metric instanceof Timer) {
        Timer m = (Timer) metric;
        Snapshot s = m.getSnapshot();
        count = m.getCount();
        rate_1m = m.getOneMinuteRate();
        rate_5m = m.getFiveMinuteRate();
        rate_15m = m.getFifteenMinuteRate();

        double div = Description.getTimeUnit(atts.get(Description.UNIT)).toNanos(1);
        p50 = s.getMedian() / div;
        p75 = s.get75thPercentile() / div;
        p95 = s.get95thPercentile() / div;
        p98 = s.get98thPercentile() / div;
        p99 = s.get99thPercentile() / div;
        p99_9 = s.get999thPercentile() / div;

        min = s.getMin() / div;
        max = s.getMax() / div;
        std_dev = s.getStdDev() / div;

    } else if (metric instanceof Histogram) {
        Histogram m = (Histogram) metric;
        Snapshot s = m.getSnapshot();
        count = m.getCount();

        p50 = s.getMedian();
        p75 = s.get75thPercentile();
        p95 = s.get95thPercentile();
        p98 = s.get98thPercentile();
        p99 = s.get99thPercentile();
        p99_9 = s.get999thPercentile();

        min = (double) s.getMin();
        avg = (double) s.getMean();
        max = (double) s.getMax();
        sum = s.getMean() * m.getCount();
        std_dev = s.getStdDev();
    }
}

From source file:org.gradle.caching.internal.packaging.impl.TarBuildCacheEntryPacker.java

private UnpackResult unpack(CacheableEntity entity, TarArchiveInputStream tarInput,
        OriginReader readOriginAction) throws IOException {
    ImmutableMap.Builder<String, CacheableTree> treesBuilder = ImmutableMap.builder();
    entity.visitTrees((name, type, root) -> {
        if (root != null) {
            treesBuilder.put(name, new CacheableTree(type, root));
        }//from w  w  w .ja va2  s . c  o  m
    });
    ImmutableMap<String, CacheableTree> treesByName = treesBuilder.build();

    TarArchiveEntry tarEntry;
    OriginMetadata originMetadata = null;
    Map<String, FileSystemLocationSnapshot> snapshots = new HashMap<String, FileSystemLocationSnapshot>();

    tarEntry = tarInput.getNextTarEntry();
    MutableLong entries = new MutableLong();
    while (tarEntry != null) {
        entries.increment(1);
        String path = tarEntry.getName();

        if (path.equals(METADATA_PATH)) {
            // handle origin metadata
            originMetadata = readOriginAction.execute(new CloseShieldInputStream(tarInput));
            tarEntry = tarInput.getNextTarEntry();
        } else {
            // handle tree
            Matcher matcher = TREE_PATH.matcher(path);
            if (!matcher.matches()) {
                throw new IllegalStateException("Cached entry format error, invalid contents: " + path);
            }

            String treeName = unescape(matcher.group(2));
            CacheableTree tree = treesByName.get(treeName);
            if (tree == null) {
                throw new IllegalStateException(String.format("No tree '%s' registered", treeName));
            }

            boolean missing = matcher.group(1) != null;
            String childPath = matcher.group(3);
            tarEntry = unpackTree(treeName, tree.getType(), tree.getRoot(), tarInput, tarEntry, childPath,
                    missing, snapshots, entries);
        }
    }
    if (originMetadata == null) {
        throw new IllegalStateException("Cached result format error, no origin metadata was found.");
    }

    return new UnpackResult(originMetadata, entries.get(), snapshots);
}

From source file:auto.json.processor.AutoJsonProcessor.java

private void defineVarsForType(TypeElement type, AutoJsonTemplateVars vars) {
    Types typeUtils = processingEnv.getTypeUtils();
    List<ExecutableElement> methods = new ArrayList<ExecutableElement>();
    findLocalAndInheritedMethods(type, methods);
    determineObjectMethodsToGenerate(methods, vars);
    ImmutableSet<ExecutableElement> methodsToImplement = methodsToImplement(methods);
    Set<TypeMirror> types = new TypeMirrorSet();
    types.addAll(returnTypesOf(methodsToImplement));
    //    TypeMirror javaxAnnotationGenerated = getTypeMirror(Generated.class);
    //    types.add(javaxAnnotationGenerated);
    TypeMirror javaUtilArrays = getTypeMirror(Arrays.class);
    if (containsArrayType(types)) {
        // If there are array properties then we will be referencing java.util.Arrays.
        // Arrange to import it unless that would introduce ambiguity.
        types.add(javaUtilArrays);/*from  ww  w  .ja va 2 s .c  om*/
    }
    BuilderSpec builderSpec = new BuilderSpec(type, processingEnv, errorReporter);
    Optional<BuilderSpec.Builder> builder = builderSpec.getBuilder();
    ImmutableSet<ExecutableElement> toBuilderMethods;
    if (builder.isPresent()) {
        types.add(getTypeMirror(BitSet.class));
        toBuilderMethods = builder.get().toBuilderMethods(typeUtils, methodsToImplement);
    } else {
        toBuilderMethods = ImmutableSet.of();
    }
    vars.toBuilderMethods = FluentIterable.from(toBuilderMethods).transform(SimpleNameFunction.INSTANCE)
            .toList();
    Set<ExecutableElement> propertyMethods = Sets.difference(methodsToImplement, toBuilderMethods);

    ImmutableSet<ExecutableElement> toBundleMethods = toBundleMethods(typeUtils, methodsToImplement);
    vars.toBundleMethods = FluentIterable.from(toBundleMethods).transform(SimpleNameFunction.INSTANCE).toList();

    propertyMethods = Sets.difference(propertyMethods, toBundleMethods);
    String pkg = TypeSimplifier.packageNameOf(type);
    TypeSimplifier typeSimplifier = new TypeSimplifier(typeUtils, pkg, types, type.asType());
    vars.imports = typeSimplifier.typesToImport();
    //    vars.generated = typeSimplifier.simplify(javaxAnnotationGenerated);
    vars.arrays = typeSimplifier.simplify(javaUtilArrays);
    vars.bitSet = typeSimplifier.simplifyRaw(getTypeMirror(BitSet.class));
    ImmutableMap<ExecutableElement, String> methodToPropertyName = methodToPropertyNameMap(propertyMethods);
    Map<ExecutableElement, String> methodToIdentifier = Maps.newLinkedHashMap(methodToPropertyName);
    fixReservedIdentifiers(methodToIdentifier);
    List<Property> props = new ArrayList<Property>();
    Map<String, Property> jprops = new HashMap<>();
    for (ExecutableElement method : propertyMethods) {
        String propertyType = typeSimplifier.simplify(method.getReturnType());
        String propertyName = methodToPropertyName.get(method);
        String identifier = methodToIdentifier.get(method);

        TypeMirror returnType = method.getReturnType();
        if (TypeKind.DECLARED.equals(returnType.getKind())) {
            if (isAutoJson((TypeElement) typeUtils.asElement(returnType))) {
                String name = returnType.toString();
                jprops.put(name, new Property(toClassName(name), identifier, method, name, typeSimplifier,
                        annotatedNames, processingEnv));
            } else {
                for (TypeMirror genericType : ((DeclaredType) returnType).getTypeArguments()) {
                    if (isAutoJson((TypeElement) typeUtils.asElement(genericType))) {
                        String name = genericType.toString();
                        jprops.put(name, new Property(toClassName(name), identifier, method, name,
                                typeSimplifier, annotatedNames, processingEnv));
                        break;
                    }
                }
            }
        }

        props.add(new Property(propertyName, identifier, method, propertyType, typeSimplifier, annotatedNames,
                processingEnv));
    }
    // If we are running from Eclipse, undo the work of its compiler which sorts methods.
    eclipseHack().reorderProperties(props);
    vars.props = props;
    vars.jprops = new ArrayList<>(jprops.values());
    vars.serialVersionUID = getSerialVersionUID(type);
    vars.formalTypes = typeSimplifier.formalTypeParametersString(type);
    vars.actualTypes = TypeSimplifier.actualTypeParametersString(type);
    vars.wildcardTypes = wildcardTypeParametersString(type);

    TypeElement parcelable = processingEnv.getElementUtils().getTypeElement("android.os.Parcelable");
    vars.parcelable = parcelable != null
            && processingEnv.getTypeUtils().isAssignable(type.asType(), parcelable.asType());
    // Check for @AutoJson.Builder and add appropriate variables if it is present.
    if (builder.isPresent()) {
        builder.get().defineVars(vars, typeSimplifier, methodToPropertyName);
    }
}

From source file:org.restlet.test.ext.apispark.conversion.swagger.v2_0.Swagger2TestCase.java

private void compareRwadefHeaders(List<Header> savedHeadersList, List<Header> translatedHeadersList) {
    if (assertBothNull(savedHeadersList, translatedHeadersList)) {
        return;//  w  w  w . j a v  a 2  s .  com
    }

    ImmutableMap<String, Header> savedHeaders = Maps.uniqueIndex(savedHeadersList,
            new Function<Header, String>() {
                public String apply(Header header) {
                    return header.getName();
                }
            });
    ImmutableMap<String, Header> translatedHeaders = Maps.uniqueIndex(translatedHeadersList,
            new Function<Header, String>() {
                public String apply(Header header) {
                    return header.getName();
                }
            });

    assertEquals(savedHeaders.size(), translatedHeaders.size());
    for (String key : savedHeaders.keySet()) {
        Header savedHeader = savedHeaders.get(key);
        Header translatedHeader = translatedHeaders.get(key);
        assertNotNull(savedHeader);
        assertNotNull(translatedHeader);

        assertEquals(savedHeader.getDefaultValue(), translatedHeader.getDefaultValue());
        assertEquals(savedHeader.getDescription(), translatedHeader.getDescription());
        assertEquals(savedHeader.getType(), translatedHeader.getType());
        assertEquals(savedHeader.isRequired(), translatedHeader.isRequired());
        // TODO: does not exist in Swagger 2.0 yet
        // assertEquals(savedHeader.isAllowMultiple(), translatedHeader.isAllowMultiple());

    }
}

From source file:com.aitorvs.autoparcel.internal.codegen.AutoParcelProcessor.java

private MethodSpec generateConstructorFromParcel(ProcessingEnvironment env, ImmutableList<Property> properties,
        ImmutableMap<TypeMirror, FieldSpec> typeAdapters) {

    // Create the PRIVATE constructor from Parcel
    MethodSpec.Builder builder = MethodSpec.constructorBuilder().addModifiers(PRIVATE) // private
            .addParameter(ClassName.bestGuess("android.os.Parcel"), "in"); // input param

    // get a code block builder
    CodeBlock.Builder block = CodeBlock.builder();

    // First thing is reading the Parcelable object version
    block.add("this.version = in.readInt();\n");

    // FIXME: 31/07/16 remove if not used
    boolean requiresSuppressWarnings = false;

    // Now, iterate all properties, check the version initialize them
    for (Property p : properties) {

        // get the property version
        int pVersion = p.version();
        if (pVersion > 0) {
            block.beginControlFlow("if (this.version >= $L)", pVersion);
        }// www .  ja  v  a  2  s. c o  m

        block.add("this.$N = ", p.fieldName);

        if (p.typeAdapter != null && typeAdapters.containsKey(p.typeAdapter)) {
            Parcelables.readValueWithTypeAdapter(block, p, typeAdapters.get(p.typeAdapter));
        } else {
            requiresSuppressWarnings |= Parcelables.isTypeRequiresSuppressWarnings(p.typeName);
            TypeName parcelableType = Parcelables.getTypeNameFromProperty(p, env.getTypeUtils());
            Parcelables.readValue(block, p, parcelableType);
        }

        block.add(";\n");

        if (pVersion > 0) {
            block.endControlFlow();
        }
    }

    builder.addCode(block.build());

    return builder.build();
}

From source file:dagger2.internal.codegen.ComponentGenerator.java

private Snippet initializeFactoryForProductionBinding(ProductionBinding binding, BindingGraph bindingGraph,
        ClassName componentName, ImmutableMap<ExecutableElement, TypeElement> dependencyMethodIndex,
        Map<TypeElement, MemberSelect> contributionFields,
        ImmutableMap<BindingKey, MemberSelect> memberSelectSnippets) {
    switch (binding.bindingKind()) {
    case COMPONENT_PRODUCTION:
        TypeElement bindingTypeElement = dependencyMethodIndex.get(binding.bindingElement());
        String sourceFieldName = CaseFormat.UPPER_CAMEL.to(LOWER_CAMEL,
                bindingTypeElement.getSimpleName().toString());
        return Snippet.format(
                Joiner.on('\n').join("new %s<%2$s>() {", "  private final %6$s %7$s = %4$s;",
                        "  @Override public %3$s<%2$s> get() {", "    return %7$s.%5$s();", "  }", "}"),
                ClassName.fromClass(Producer.class), TypeNames.forTypeMirror(binding.key().type()),
                ClassName.fromClass(ListenableFuture.class),
                contributionFields.get(bindingTypeElement).getSnippetFor(componentName),
                binding.bindingElement().getSimpleName().toString(),
                TypeNames.forTypeMirror(bindingTypeElement.asType()), sourceFieldName);
    case IMMEDIATE:
    case FUTURE_PRODUCTION:
        List<Snippet> parameters = Lists.newArrayListWithCapacity(binding.dependencies().size() + 2);
        parameters.add(contributionFields.get(binding.bindingTypeElement()).getSnippetFor(componentName));
        parameters.add(contributionFields.get(bindingGraph.componentDescriptor().executorDependency().get())
                .getSnippetFor(componentName));
        parameters.addAll(getProducerDependencyParameters(bindingGraph, componentName, binding.dependencies(),
                memberSelectSnippets));/*from   w w w  . j  a v  a  2s .  co  m*/

        return Snippet.format("new %s(%s)", factoryNameForProductionBinding(binding),
                Snippet.makeParametersSnippet(parameters));
    default:
        throw new AssertionError();
    }
}

From source file:org.restlet.test.ext.apispark.conversion.swagger.v2_0.Swagger2TestCase.java

private void compareRwadefSections(Contract savedContract, Contract translatedContract) {
    if (assertBothNull(savedContract.getSections(), translatedContract.getSections())) {
        return;/* w w  w.  j  a v  a2 s .c o  m*/
    }

    ImmutableMap<String, Section> savedSections = Maps.uniqueIndex(savedContract.getSections(),
            new Function<Section, String>() {
                public String apply(Section section) {
                    return section.getName();
                }
            });
    ImmutableMap<String, Section> translatedSections = Maps.uniqueIndex(translatedContract.getSections(),
            new Function<Section, String>() {
                public String apply(Section section) {
                    return section.getName();
                }
            });

    assertEquals(savedSections.size(), translatedSections.size());
    for (String key : savedSections.keySet()) {
        Section savedSection = savedSections.get(key);
        Section translatedSection = translatedSections.get(key);
        assertNotNull(savedSection);
        assertNotNull(translatedSection);
        assertEquals(savedSection.getDescription(), translatedSection.getDescription());
    }
}

From source file:org.restlet.test.ext.apispark.conversion.swagger.v2_0.Swagger2TestCase.java

private void compareRwadefProperties(List<Property> savedPropertiesList,
        List<Property> translatedPropertiesList) {
    if (assertBothNull(savedPropertiesList, translatedPropertiesList)) {
        return;//from  w w  w.j  av  a  2s.c om
    }

    ImmutableMap<String, Property> savedProperties = Maps.uniqueIndex(savedPropertiesList,
            new Function<Property, String>() {
                public String apply(Property property) {
                    return property.getName();
                }
            });
    ImmutableMap<String, Property> translatedProperties = Maps.uniqueIndex(translatedPropertiesList,
            new Function<Property, String>() {
                public String apply(Property property) {
                    return property.getName();
                }
            });

    assertEquals(savedProperties.size(), translatedProperties.size());
    for (String key : savedProperties.keySet()) {
        Property savedProperty = savedProperties.get(key);
        Property translatedProperty = translatedProperties.get(key);
        assertNotNull(savedProperty);
        assertNotNull(translatedProperty);

        assertEquals(savedProperty.getDefaultValue(), translatedProperty.getDefaultValue());
        assertEquals(savedProperty.getDescription(), translatedProperty.getDescription());
        assertEquals(savedProperty.getExample(), translatedProperty.getExample());
        assertEquals(savedProperty.getMax(), translatedProperty.getMax());
        assertEquals(savedProperty.getMin(), translatedProperty.getMin());
        assertEquals(savedProperty.getType(), translatedProperty.getType());
        assertEquals(savedProperty.getMaxOccurs(), translatedProperty.getMaxOccurs());
        assertEquals(savedProperty.getMinOccurs(), translatedProperty.getMinOccurs());

        compareRwadefProperties(savedProperty.getProperties(), translatedProperty.getProperties());
        compareStringLists(savedProperty.getEnumeration(), translatedProperty.getEnumeration());
    }
}