return ImmutableSet.copyOf(elements);
    }
  }

  public static class ImmutableSetUnsizedBuilderGenerator extends TestStringSetGenerator {
    @Override
    protected Set<String> create(String[] elements) {
      ImmutableSet.Builder<String> builder = ImmutableSet.builder();
      for (String e : elements) {
        builder.add(e);
      }
      return builder.build();
    }
  }

    }

    @Override
    public SampleElements<Entry<K, V>> samples() {
      return generator.samples();
    }

    @Override
    public Map<K, V> create(Object... elements) {
      return generator.create(elements);
    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override

				}
			} else {
				return fmt.Errorf("expecting pod name or config dump, found: %d", len(args))
			}

			analyzer, err := NewAnalyzer(configDump)
			if err != nil {
				return err
			}
			analyzer.Print(cmd.OutOrStdout())
			return nil
		},
		ValidArgsFunction: completion.ValidPodsNameArgs(ctx),
	}

            if ("true".equalsIgnoreCase(s)) {
                return Boolean.TRUE;
            } else if ("false".equalsIgnoreCase(s)) {
                return Boolean.FALSE;
            } else if (s.equals("0")) {
                return Boolean.FALSE;
            } else {
                return Boolean.TRUE;
            }
        } else {
            return Boolean.TRUE;
        }
    }

    /**

            return null;
        }

        MetadataGraphVertex v = new MetadataGraphVertex(md);
        v.setCompareVersion(versionedVertices);
        v.setCompareScope(scopedVertices);

        for (MetadataGraphVertex gv : vertices) {
            if (gv.equals(v)) {
                return gv;
            }
        }

        return null;
    }

        return c.getChild("version").getValue();
    }

    private String extractGoalPrefix(PlexusConfiguration c) {
        return c.getChild("goalPrefix").getValue();
    }

    private String extractName(PlexusConfiguration c) {
        return c.getChild("name").getValue();
    }

    private String extractDescription(PlexusConfiguration c) {
        return c.getChild("description").getValue();
    }

-A ISTIO_OUTPUT -m owner --gid-owner 1337 -j RETURN
-A ISTIO_OUTPUT -p tcp --dport 53 -j REDIRECT --to-ports 15053
-A ISTIO_OUTPUT -d 127.0.0.1/32 -j RETURN
-A ISTIO_OUTPUT -j ISTIO_REDIRECT
-A OUTPUT -p udp -j ISTIO_OUTPUT
-A ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 1337 -j RETURN
-A ISTIO_OUTPUT -p udp --dport 53 -m owner --gid-owner 1337 -j RETURN

		return modelType.MethodByName(string(callbackTypeBeforeSave))
	case callbackTypeAfterSave:
		return modelType.MethodByName(string(callbackTypeAfterSave))
	case callbackTypeBeforeDelete:
		return modelType.MethodByName(string(callbackTypeBeforeDelete))
	case callbackTypeAfterDelete:
		return modelType.MethodByName(string(callbackTypeAfterDelete))
	case callbackTypeAfterFind:
		return modelType.MethodByName(string(callbackTypeAfterFind))

            return pathL;
        }

        final String path = getLocalizedPagePath(page, null, null);
        final String p = pageCacheMap.get(path);
        if (p != null) {
            return p;
        }
        if (existsPage(path)) {
            pageCacheMap.put(pathLC, path);
            return path;
        }

        return "index.jsp";
    }

    return emptySet();
  }

  protected Collection<Method> suppressForCheckedSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForAbstractSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForConcurrentSkipListSetNatural() {
    return emptySet();
  }