_specification = new HpSpecification();
        }
        return _specification;
    }

    protected void assertQueryPurpose() {
    }

    protected void assertAggregationPurpose() {
    }

    protected void assertSpecifyPurpose() {
    }

    public static class HpSpecification {
        protected List<String> columnList = new ArrayList<>();

    return queryList.toArray(new Element[0]);
  }

  private Set<Element> createData() {
    Set<Element> set = Sets.newHashSetWithExpectedSize(size);
    while (set.size() < size) {
      set.add(newElement());
    }
    return set;
  }

  private Element newElement() {
    int value = random.nextInt();
    return isUserTypeFast ? new Element(value) : new SlowElement(value);
  }

            checkNoConflict(comparator.compare(prevKey, key) != 0, "key", prevEntry, entry);
            prevKey = key;
          }
        }
        return new ImmutableSortedMap<>(
            new RegularImmutableSortedSet<K>(new RegularImmutableList<K>(keys), comparator),
            new RegularImmutableList<V>(values));
    }
  }

  /**
   * Returns a builder that creates immutable sorted maps whose keys are ordered by their natural

    nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
    sameElements = new Target(asList(createSamplesArray()), "sameElements");
    containsDuplicates =
        new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");
    partialOverlap = new Target(MinimalCollection.of(e2(), e3()), "partialOverlap");

    }

    @Test(expected = IllegalArgumentException.class)
    public void testExceptionOnEmpty() {
        new BwcVersions(asList("foo", "bar"), Version.fromString("7.0.0"));
    }

    @Test(expected = IllegalStateException.class)
    public void testExceptionOnNonCurrent() {
        new BwcVersions(singletonList(formatVersionToLine("6.5.0")), Version.fromString("7.0.0"));
    }

                highlightedQuerySet = new HashSet<>();
                request.setAttribute(Constants.HIGHLIGHT_QUERIES, highlightedQuerySet);
                fieldLogMap = (Map<String, List<String>>) request.getAttribute(Constants.FIELD_LOGS);
                if (fieldLogMap == null) {
                    fieldLogMap = new HashMap<>();
                    request.setAttribute(Constants.FIELD_LOGS, fieldLogMap);

  }

  private static final DiscreteDomain<Integer> UNBOUNDED_THROWING_DOMAIN =
      new DiscreteDomain<Integer>() {
        @Override
        public Integer next(Integer value) {
          throw new AssertionError();
        }

        @Override
        public Integer previous(Integer value) {
          throw new AssertionError();
        }

        @Override

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultisetForEachEntryTester<E> extends AbstractMultisetTester<E> {
  public void testForEachEntry() {
    List<Entry<E>> expected = new ArrayList<>(getMultiset().entrySet());
    List<Entry<E>> actual = new ArrayList<>();
    getMultiset()
        .forEachEntry((element, count) -> actual.add(Multisets.immutableEntry(element, count)));
    assertEqualIgnoringOrder(expected, actual);
  }

     */
    private static final long serialVersionUID = 1913365058349456689L;

    /**
     * Creates a new SMBProtocolDowngradeException with no message.
     */
    public SMBProtocolDowngradeException() {
    }

    /**
     * Creates a new SMBProtocolDowngradeException with the specified detail message and cause.
     *
     * @param message the detail message

    /**
     * Constructs a new TransportException with no detail message.
     */
    public TransportException() {
    }

    /**
     * Constructs a new TransportException with the specified detail message.
     * @param msg the detail message
     */
    public TransportException(final String msg) {
        super(msg);
    }

    /**
     * Constructs a new TransportException with the specified cause.