char c2 = seq.charAt(index);
        if (Character.isLowSurrogate(c2)) {
          return Character.toCodePoint(c1, c2);
        }
        throw new IllegalArgumentException(
            "Expected low surrogate but got char '"
                + c2
                + "' with value "
                + (int) c2
                + " at index "
                + index
                + " in '"
                + seq

          // decoding stream may differ from the messages for the decode methods.
        } catch (IOException e) {
          fail("Expected DecodingException but got: " + e);
        }
      }
    };

    abstract void assertFailsToDecode(
        BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage);
  }

  @GwtIncompatible // Reader/Writer

        protwordsFile.reload(null);

        PagingList<ProtwordsItem> list = protwordsFile.selectList(0, 100);

        // The file parsing may treat the escaped sequences differently
        // Check what we actually got
        assertTrue("Should have at least 3 items", list.size() >= 3);

        // Find and verify the expected items
        boolean foundTab = false;
        boolean foundNewline = false;

      log(throwable);
    }
  }

  private static void log(Throwable throwable) {
    String message =
        (throwable instanceof Error)
            ? "Input Future failed with Error"
            : "Got more than one input Future failure. Logging failures after the first";
    logger.get().log(SEVERE, message, throwable);
  }

  @Override
  final void addInitialException(Set<Throwable> seen) {
    checkNotNull(seen);

          BigInteger quotient = BigIntegerMath.divide(p, q, UNNECESSARY);
          BigInteger undone = quotient.multiply(q);
          if (!p.equals(undone)) {
            failFormat("expected %s.multiply(%s) = %s; got %s", quotient, q, p, undone);
          }
          assertTrue(dividesEvenly);
        } catch (ArithmeticException e) {
          assertFalse(dividesEvenly);
        }
      }
    }
  }

            response.readBytesWireFormat(malformedBuffer, 0);
        });

        assertTrue(exception.getMessage().contains("Structure size is not 65"));
        assertTrue(exception.getMessage().contains("got: 64"));
    }

    /**
     * Test that insufficient buffer size is properly detected.
     */
    @Test
    public void testInsufficientBufferSize() {

	c.conn.got = append(c.conn.got, query)
	return c.Tx.QueryContext(ctx, query, args...)
}

func (c *wrapperTx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
	c.conn.got = append(c.conn.got, query)
	return c.Tx.QueryRowContext(ctx, query, args...)
}

type wrapperConnPool struct {
	db     *sql.DB
	got    []string
	expect []string
}

                last = smbe;
            } catch (final CIFSException e) {
                log.debug("send", e);
                last = e;
            }
            // If we get here, we got the 'The Parameter is incorrect' error or a transport exception
            // Disconnect and try again from scratch.

            if (log.isDebugEnabled()) {

                                try {
                                    log.warn("Got NT_STATUS_USER_SESSION_DELETED, disconnecting transport");
                                    this.transport.disconnect(true);
                                } catch (IOException e1) {
                                    log.warn("Got NT_STATUS_USER_SESSION_DELETED, disconnected transport with error", e1);
                                }

			}
			if got == nil {
				t.Fatalf("UnixSecondSerializer.Value() = nil, want %v", tt.want)
			}
			if gotTime, ok := got.(time.Time); !ok {
				t.Errorf("UnixSecondSerializer.Value() returned %T, expected time.Time", got)
			} else if !tt.want.(time.Time).Equal(gotTime) {
				t.Errorf("UnixSecondSerializer.Value() = %v, want %v", got, tt.want)
			}
		})
	}