// look for last ANSI escape sequence to check if nextColor
            Matcher matcher = LAST_ANSI_SEQUENCE.matcher(line);
            String nextColor = "";
            if (matcher.find()) {
                nextColor = matcher.group(1);
                if (ANSI_RESET.equals(nextColor)) {
                    // last ANSI escape code is reset: no next color

      return label;
    }
  }

  /** Convenient subsets of the {@link Timeout} enumeration for specifying scenario outcomes. */
  private enum TimeoutsToUse {
    ANY(Timeout.values()),
    PAST(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO),
    FUTURE(Timeout.SMALL, Timeout.MAX),
    SMALL(Timeout.SMALL),
    FINITE(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO, Timeout.SMALL),

        }

        return processFieldConfigs(dataMap, fieldConfigs);
    }

    /**
     * Get the last modified date.
     * @param dataMap The data map.
     * @param responseData The response data.
     * @return The last modified date.
     */
    protected Date getLastModified(final Map<String, Object> dataMap, final ResponseData responseData) {

			t.Errorf("invalid price for product #%v, expects: %v, got %v", idx, value, products[idx].Price)
		}
	}

	DB.Model(&products).Update("Name", "product-name")

	// will set all product's price to last product's price + 10
	for idx, value := range []int64{410, 410, 410} {
		if products[idx].Price != value {
			t.Errorf("invalid price for product #%v, expects: %v, got %v", idx, value, products[idx].Price)
		}
	}

	ReplicaStatus = "replica-status"
	// ReplicaTimestamp - the last time a replica was received by this cluster for this object version
	ReplicaTimestamp = "replica-timestamp"
	// TaggingTimestamp - the last time a tag metadata modification happened on this cluster for this object version
	TaggingTimestamp = "tagging-timestamp"

    @Override
    public int encode(byte[] buffer, int offset) {
        int start = offset;

        // Write context header
        SMBUtil.writeInt4(0, buffer, offset); // Next (offset to next context, 0 for last)
        offset += 4;

        SMBUtil.writeInt2(16, buffer, offset); // NameOffset (from start of context)
        offset += 2;

        SMBUtil.writeInt2(4, buffer, offset); // NameLength
        offset += 2;

     * This cache is refreshed periodically based on the lastLoadedTime.
     */
    protected volatile String[] dataStoreNames = StringUtil.EMPTY_STRINGS;

    /**
     * Timestamp of the last time data store names were loaded from plugin files.
     * Used to implement a time-based cache refresh mechanism.
     * Volatile to ensure visibility across threads.
     */
    protected volatile long lastLoadedTime = 0;

        PluginPrefixResult result = resolveFromRepository(request, candidates);

        // If we haven't been able to resolve the plugin from the repository,
        // as a last resort, we go through all declared plugins, load them
        // one by one, and try to find a matching prefix.
        if (result == null && build != null) {
            result = resolveFromProject(request, build.getPlugins());

func (target *WebhookTarget) SendFromStore(key store.Key) error {
	if err := target.init(); err != nil {
		return err
	}

	eventData, eErr := target.store.Get(key)
	if eErr != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and would've been already been sent successfully.
		if os.IsNotExist(eErr) {
			return nil
		}

    if (!hasNext()) throw NoSuchElementException()

    // Compute the next set of routes to attempt.
    val routes = mutableListOf<Route>()
    while (hasNextProxy()) {
      // Postponed routes are always tried last. For example, if we have 2 proxies and all the
      // routes for proxy1 should be postponed, we'll move to proxy2. Only after we've exhausted
      // all the good routes will we attempt the postponed routes.