// Print each group
        for (GroupAnalysis group : sortedGroups) {
            System.out.printf("%nPaths ending with '%s':%n", group.name);
            System.out.printf("Total potential savings: %dKB%n", group.totalSavings / 1024);
            System.out.printf("Total memory: %dKB%n", group.totalMemory / 1024);
            System.out.printf("Total unique values: %d%n", group.totalUnique);

- find accounts whose group memberships have changed; access policies available to a credential are updated to reflect the change, i.e. they will lose any privileges associated with a group they are removed from, and gain any privileges associated with a group they are added to.

				return
			}
		case "Source":
			z.Source, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Source")
				return
			}
		case "Group":
			z.Group, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Group")
				return
			}
		case "Owner":
			z.Owner, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Owner")
				return
			}

                if (matcher.group(2) != null) {
                    final String attrPair = matcher.group(2).substring(1, matcher.group(2).length() - 1);
                    final Matcher equalMatcher = Pattern.compile("([\\w\\-]+)=(\\S+)").matcher(attrPair);
                    if (equalMatcher.matches()) {
                        tag.setAttr(equalMatcher.group(1), equalMatcher.group(2));

            String link = xrefMatcher.group(1);
            if (link.contains("#")) {
                Matcher linkMatcher = linkWithHashPattern.matcher(link);
                if (linkMatcher.matches()) {
                    MatchResult result = linkMatcher.toMatchResult();
                    String fileName = getFileName(result.group(1), sourceFile);

    return this;
  }

  @CanIgnoreReturnValue
  public EquivalenceTester<T> addEquivalenceGroup(Iterable<T> group) {
    delegate.addRelatedGroup(group);
    items.addAll(ImmutableList.copyOf(group));
    return this;
  }

  /** Run tests on equivalence methods, throwing a failure on an invalid test */
  @CanIgnoreReturnValue
  public EquivalenceTester<T> test() {
    for (int run = 0; run < REPETITIONS; run++) {

    return this;
  }

  @CanIgnoreReturnValue
  public EquivalenceTester<T> addEquivalenceGroup(Iterable<T> group) {
    delegate.addRelatedGroup(group);
    items.addAll(ImmutableList.copyOf(group));
    return this;
  }

  /** Run tests on equivalence methods, throwing a failure on an invalid test */
  @CanIgnoreReturnValue
  public EquivalenceTester<T> test() {
    for (int run = 0; run < REPETITIONS; run++) {

            "scaleDistribution": {
              "type": "linear"
            },
            "showPoints": "never",
            "spanNulls": true,
            "stacking": {
              "group": "A",
              "mode": "none"
            },
            "thresholdsStyle": {
              "mode": "off"
            }
          },
          "mappings": [],
          "thresholds": {

    try {
      tester.testEquals();
    } catch (AssertionFailedError e) {
      assertErrorMessage(e, "foo [group 1, item 1] must be Object#equals to bar [group 1, item 2]");
      return;
    }
    fail("should failed because of unequal objects in the same equality group");
  }

  public void testTransitivityBrokenAcrossEqualityGroups() {
    EqualsTester tester =
        new EqualsTester()

package clause

// GroupBy group by clause
type GroupBy struct {
	Columns []Column
	Having  []Expression
}

// Name from clause name
func (groupBy GroupBy) Name() string {
	return "GROUP BY"
}

// Build build group by clause
func (groupBy GroupBy) Build(builder Builder) {
	for idx, column := range groupBy.Columns {
		if idx > 0 {
			builder.WriteByte(',')
		}

		builder.WriteQuoted(column)
	}