*     control and the underlying method or constructor is inaccessible.
   * @throws IllegalArgumentException if the number of actual and formal parameters differ; if an
   *     unwrapping conversion for primitive arguments fails; or if, after possible unwrapping, a
   *     parameter value cannot be converted to the corresponding formal parameter type by a method
   *     invocation conversion.

        #    ; NUMERIC = $$AutoMapping$$ ; DECIMAL = $$AutoMapping$$
        #}
    }
    # - - - - - - - - - -/
}
# ----------------/
#
# Default mapping as follows:
# --------------------------------------------------------
# | JDBC Type     | Java Native          | CSharp Native |
# | ------------------------------------------------------

                        </ol>
                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <la:form action="/admin/dict/mapping/upload" enctype="multipart/form-data">
                <la:hidden property="dictId"/>
                <div class="row">
                    <div class="col-md-12">

            // Positive values not in DOS_ERROR_CODES map to NT_STATUS_UNSUCCESSFUL
            expected = NtStatus.NT_STATUS_UNSUCCESSFUL;
        }
        assertEquals(expected, ex.getNtStatus(), "Status should match mapping or fallback");
    }

    /**
     * Verify that root causes are stored and returned correctly.
     */
    @Test
    @DisplayName("Root cause propagation")
    void testRootCausePropagation() {

        final Map<String, String> mapping = getQueryLanguageMappingMap();
        return stream(langs).get(stream -> stream.map(s -> {
            if (StringUtil.isBlank(s)) {
                return null;
            }
            final String lang1 = mapping.get(s);
            if (lang1 != null) {
                return lang1;
            }
            return mapping.get(s.split("[\\-_]")[0]);

                    appendJson("search-field", searchFieldMap, buf).append(',');
                    final Map<String, List<String>> requestHeaderMap = entity.getRequestHeaderList()
                            .stream()
                            .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));

        ArgumentCaptor<String> msgCap = ArgumentCaptor.forClass(String.class);
        verify(handler, atLeastOnce()).handle(codeCap.capture(), msgCap.capture());

        // Assert at least one captured pair is a known mapping (happy path spot check)
        assertTrue(codeCap.getAllValues().contains(WinError.ERROR_ACCESS_DENIED));
        int idx = codeCap.getAllValues().indexOf(WinError.ERROR_ACCESS_DENIED);

   * <p>Due to the property that values in a BiMap are unique, this will tend to execute in
   * faster-than-linear time.
   *
   * @param value the object to search for in the values of this BiMap
   * @return true if a mapping exists from a key to the specified value
   */
  @Override
  public boolean containsValue(@Nullable Object value) {
    return findEntryByValue(value) != ABSENT;
  }

  @Override

  protected Table<String, Integer, C> table;

  /**
   * Creates a table with the specified data.
   *
   * @param data the table data, repeating the sequence row key, column key, value once per mapping
   * @throws IllegalArgumentException if the size of {@code data} isn't a multiple of 3
   * @throws ClassCastException if a data element has the wrong type
   */

   */
  @Override
  public abstract ImmutableCollection<V> get(K key);

  /**
   * Returns an immutable multimap which is the inverse of this one. For every key-value mapping in
   * the original, the result will have a mapping with key and value reversed.
   *
   * @since 11.0
   */
  public abstract ImmutableMultimap<V, K> inverse();

  /**