public static final String CRAWL_ORDER = "crawl.order";
        }

        // meta.*
        // meta.<field>=<value>

        // value.*
        // value.<field>=<value>

        // script.*
        // script.<field>=<value>

        // field.*
        // field.<field>=<value>
    }

	}
	for name, value := range httpStats.TotalS35xxErrors.APIStats {
		m.Set(apiRequests5xxErrorsTotal, float64(value), "name", name, "type", "s3")
	}
	for name, value := range httpStats.TotalS34xxErrors.APIStats {
		m.Set(apiRequests4xxErrorsTotal, float64(value), "name", name, "type", "s3")
	}
	for name, value := range httpStats.TotalS3Canceled.APIStats {
		m.Set(apiRequestsCanceledTotal, float64(value), "name", name, "type", "s3")

    <type id="web" />
  </component>
  <component name="NullableNotNullManager">
    <option name="myDefaultNullable" value="javax.annotation.Nullable" />
    <option name="myDefaultNotNull" value="javax.annotation.Nonnull" />
    <option name="myOrdered" value="true" />
    <option name="myNullables">
      <value>
        <list size="18">
          <item index="0" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />

<div class="wrapper">
    <jsp:include page="/WEB-INF/view/common/admin/header.jsp"></jsp:include>
    <jsp:include page="/WEB-INF/view/common/admin/sidebar.jsp">
        <jsp:param name="menuCategoryType" value="log"/>
        <jsp:param name="menuType" value="failureUrl"/>
    </jsp:include>
    <main class="content-wrapper">
        <div class="content-header">
            <div class="container-fluid">
                <div class="row mb-2">

			}},
			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
			[]interface{}{"1", "jinzhu", 18},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{

    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testValuesInOrder() {
    List<V> expected = new ArrayList<>();
    for (Entry<K, V> entry : getOrderedElements()) {
      expected.add(entry.getValue());
    }
    assertEqualInOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)

    for (Entry<K, V> entry : entries) {
      resetContainer();
      K k = entry.getKey();
      V v = entry.getValue();

      Set<V> values = multimap().get(k);
      Set<V> expectedValues = copyToSet(values);

      assertFalse(multimap().put(k, v));
      assertEquals(expectedValues, values);
      assertGet(k, expectedValues);
    }
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})

    assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(
        "putIfAbsent(present, value) should return existing value",
        v0(),
        getMap().putIfAbsent(k0(), v3()));

public class MapMergeTester<K, V> extends AbstractMapTester<K, V> {
  @MapFeature.Require(SUPPORTS_PUT)
  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(

  }

  static final class Item<T> {
    final T value;
    final int groupNumber;
    final int itemNumber;

    Item(T value, int groupNumber, int itemNumber) {
      this.value = value;
      this.groupNumber = groupNumber;
      this.itemNumber = itemNumber;
    }

    @Override
    public String toString() {
      return value + " [group " + (groupNumber + 1) + ", item " + (itemNumber + 1) + ']';