assertEquals(dataSize, result);
        for (int i = 0; i < dataSize; i++) {
            assertEquals(sourceData[i], outputBuffer[i]);
        }
    }

    @Test
    void testToString() {
        String result = response.toString();
        assertNotNull(result);
        assertTrue(result.startsWith("TransCallNamedPipeResponse["));
        assertTrue(result.endsWith("]"));
    }

    @Test

* `allow_origin_regex` - Uma string regex para corresponder às origens que devem ter permissão para fazer requisições de origem cruzada. Por exemplo, `'https://.*\.example\.org'`.

  }

  static class DecoupledClassLoader extends URLClassLoader {

    public DecoupledClassLoader(URL[] urls) {
      super(urls);
    }

    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {

        DurationSpec that = (DurationSpec) o;
        return unit.toNanos(duration) == that.unit.toNanos(that.duration);
      }
      return false;
    }

    @Override
    public String toString() {
      return MoreObjects.toStringHelper(this)
          .add("duration", duration)
          .add("unit", unit)
          .toString();
    }
  }

	if err = validateTransitionTier(bucketLifecycle); err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Create a map of updated set of rules in request
	updatedRules := make(map[string]lifecycle.Rule, len(bucketLifecycle.Rules))
	for _, rule := range bucketLifecycle.Rules {
		updatedRules[rule.ID] = rule
	}

	// Get list of rules for the bucket from disk

          securityContext: {{ toYaml . | nindent 12}}
          {{- end }}
          {{- end }}
        {{- with .Values.extraContainers }}
          {{- if eq (typeOf .) "string" }}
            {{- tpl . $ | nindent 8 }}
          {{- else }}
            {{- toYaml . | nindent 8 }}
          {{- end }}
        {{- end }}
      {{- with .Values.nodeSelector }}

## Conflict Resolution

            "512, FILE_NOTIFY_CHANGE_STREAM_NAME", "1024, FILE_NOTIFY_CHANGE_STREAM_SIZE", "2048, FILE_NOTIFY_CHANGE_STREAM_WRITE" })
    void testCompletionFilterConstants(int value, String description) {
        // Given & When
        request.setCompletionFilter(value);
        byte[] buffer = new byte[512];
        request.writeBytesWireFormat(buffer, 0);

        // Then

* The API checks that `username` and `password`, and responds with a "token" (we haven't implemented any of this yet).
    * A "token" is just a string with some content that we can use later to verify this user.
    * Normally, a token is set to expire after some time.
        * So, the user will have to log in again at some point later.

		atomic.StoreInt64(&m.LastPing, time.Now().Unix())
		return pongMsg{}
	}
}

// disconnect will disconnect the mux.
// m.recvMu must be locked when calling this function.
func (m *muxServer) disconnect(msg string, locked bool) {
	if debugPrint {
		fmt.Println("Mux", m.ID, "disconnecting. Reason:", msg)
	}
	if msg != "" {
		m.send(message{Op: OpMuxServerMsg, MuxID: m.ID, Flags: FlagPayloadIsErr | FlagEOF, Payload: []byte(msg)})