public void whenCalculatingPowerSet_thenCorrect() {
    Set<Character> chars = ImmutableSet.of('a', 'b');
 
    Set<Set<Character>> result = Sets.powerSet(chars);
 
    Set<Character> empty =  ImmutableSet.<Character> builder().build();
    Set<Character> a = ImmutableSet.of('a');
    Set<Character> b = ImmutableSet.of('b');
    Set<Character> aB = ImmutableSet.of('a', 'b');
 
    assertThat(result, contains(empty, a, b, aB));
}

        

class GFG { 
  
    // Driver's code 
    public static void main(String[] args) 
    { 
  
        // Creating a set 
        Set<Integer> 
            set = Sets.newHashSet(1, 2, 3); 
  
        // powerSet to store all subsets of a set 
        Set<Set<Integer> > 
            powerSet = Sets.powerSet(set); 
  
        // Displaying all possible subsets of a set 
        for (Set<Integer> s : powerSet) 
            System.out.println(s); 
    } 
} 

        

class SetUtils
{
	// Java program to demonstrate Guava's Sets.powerSet() method
	public static void main(String[] args)
	{
		Set<Integer> set = Sets.newHashSet(1, 2, 3);
		Set<Set<Integer>> powerSet = Sets.powerSet(set);

		for (Set<Integer> s: powerSet)
			System.out.println(s);
	}
}

        

public static <T> Set<Set<T>> powerSet(Set<T> originalSet) {
    Set<Set<T>> sets = new HashSet<Set<T>>();
    if (originalSet.isEmpty()) {
        sets.add(new HashSet<T>());
        return sets;
    }
    List<T> list = new ArrayList<T>(originalSet);
    T head = list.get(0);
    Set<T> rest = new HashSet<T>(list.subList(1, list.size())); 
    for (Set<T> set : powerSet(rest)) {
        Set<T> newSet = new HashSet<T>();
        newSet.add(head);
        newSet.addAll(set);
        sets.add(newSet);
        sets.add(set);
    }       
    return sets;
}  

        

public static void main(String[] args) { 
	Set<String> animals = ImmutableSet.of("gerbil", "hamster");
	Set<String> fruits = ImmutableSet.of("apple", "orange", "banana");

	Set<Set<String>> animalSets = Sets.powerSet(animals);
	// {{}, {"gerbil"}, {"hamster"}, {"gerbil", "hamster"}}
}

        

private void initPowersetIterator() {
    // Create set of definition with leftover quantities
    Set<T> leftOverQuantities = new HashSet<>();
    for (T def : allDefintions) {
        if (roundSize.get(def) < def.numberOfLicenses()) {
            leftOverQuantities.add(def);
        }
    }
    if (leftOverQuantities.size() == 0) {
        hasNext = false;
        return;
    } else {
        hasNext = true;
        Set<Set<T>> definitionPowerset = Sets.powerSet(leftOverQuantities);
        List<Set<T>> sorted = new ArrayList<>(definitionPowerset);
        sorted.sort(getIncreasingSizeComparator());
        definitionPowersetIterator = sorted.iterator();
    }

}

        

public void testContainsAll() {
 ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
 for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) {
  assertTrue(set.containsAll(subset));
 }
 for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) {
  assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9))));
 }
 assertFalse(set.containsAll((Collection<?>) ImmutableSet.of("blah")));
}

        

public void recompile() {
  TIntIntIterator it = disposalAction.shaderPrograms.iterator();
  while (it.hasNext()) {
    it.advance();
    GL20.glDeleteProgram(it.value());
  }
  disposalAction.shaderPrograms.clear();
  uniformLocationMap.clear();
  bindMap.clear();
  disposalAction.shaderPrograms.put(0, shader.linkShaderProgram(0));
  for (Set<ShaderProgramFeature> permutation : Sets.powerSet(shader.getAvailableFeatures())) {
    int featureMask = ShaderProgramFeature.getBitset(permutation);
    disposalAction.shaderPrograms.put(featureMask, shader.linkShaderProgram(featureMask));
  }
  //resolves #966
  //Some of the uniforms are not updated constantly between frames
  //this function will rebind any uniforms that are not bound
  rebindVariables(materialData);
}

        

private void registerAllShaderPermutations() {
  Set<Set<ShaderProgramFeature>> allPermutations = Sets.powerSet(availableFeatures);
  for (Set<ShaderProgramFeature> permutation : allPermutations) {
    int fragShaderId = compileShader(GL20.GL_FRAGMENT_SHADER, permutation);
    int vertShaderId = compileShader(GL20.GL_VERTEX_SHADER, permutation);
    if (compileSuccess(fragShaderId) && compileSuccess(vertShaderId)) {
      int featureHash = ShaderProgramFeature.getBitset(permutation);
      disposalAction.fragmentPrograms.put(featureHash, fragShaderId);
      disposalAction.vertexPrograms.put(featureHash, vertShaderId);
    } else {
      throw new RuntimeException(String.format("Shader '%s' failed to compile for features '%s'.%n%n"
              + "Vertex Shader Info: %n%s%n"
              + "Fragment Shader Info: %n%s",
          getUrn(), permutation,
          getLogInfo(vertShaderId), getLogInfo(fragShaderId)));
    }
  }
  logger.debug("Compiled {} permutations for {}.", allPermutations.size(), getUrn());
}

        

public List<Set<Expression>> enumerateGroupingSets()
{
  return ImmutableList.copyOf(Sets.powerSet(columns.stream()
      .map(QualifiedNameReference::new)
      .collect(toSet())));
}