Iterator<List<Integer>> iterator = partitions.iterator();

    // Changes before the partition is retrieved are reflected
    list.set(1, 4);

    List<Integer> first = iterator.next();

    // Changes after are not
    list.set(0, 5);

    assertEquals(ImmutableList.of(3, 4), first);
  }

  @J2ktIncompatible // Arrays.asList(...).subList() doesn't implement RandomAccess in J2KT.

  }

  int getSuccessor(int entryIndex) {
    return (entryIndex + 1 < size) ? entryIndex + 1 : -1;
  }

  /**
   * Updates the index an iterator is pointing to after a call to remove: returns the index of the
   * entry that should be looked at after a removal on indexRemoved, with indexBeforeRemove as the
   * index that *was* the next entry that would be looked at.
   */

  public static <E> ImmutableList<E> of(
      E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10, E e11) {
    return construct(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11);
  }

  // These go up to eleven. After that, you just get the varargs form, and
  // whatever warnings might come along with it. :(

  /**
   * Returns an immutable list containing the given elements, in order.
   *

                if (ssn.getExpiration() != null && ssn.getExpiration() < now && !ssn.isInUse()) {
                    if (log.isDebugEnabled()) {
                        log.debug("Closing session after timeout " + ssn);
                    }
                    ssn.logoff(false, false);
                }
            }
        }

    }

    /**
     * Sets the character encoding for the request.
     *
     * @param encoding the encoding
     * @return this CurlRequest instance
     * @throws CurlException if the method is called after the param method
     */
    public CurlRequest encoding(final String encoding) {
        if (paramList != null) {
            throw new CurlException("This method must be called before param method.");
        }

    }

    /**
     * Trims the prefix.
     *
     * @param propertyName
     *            The property name
     * @return The result after trimming
     */
    protected String trimPrefix(final String propertyName) {
        if (prefix == null) {
            return propertyName;
        }
        return propertyName.substring(prefix.length());

        return name.endsWith(".log") || name.endsWith(".log.gz");
    }

    /**
     * Starts a reindex operation with the specified parameters.
     *
     * @param replaceAliases whether to replace aliases after reindexing
     * @param resetDictionaries whether to reset dictionaries during reindexing
     * @param numberOfShards the number of shards for the new index

            this.parameterOffset += this.pad1;

            this.totalParameterCount = writeParametersWireFormat(this.txn_buf, this.bufParameterOffset);
            this.bufDataOffset = this.totalParameterCount; // data comes right after data

            int available = this.maxBufferSize - this.parameterOffset;
            this.parameterCount = Math.min(this.totalParameterCount, available);
            available -= this.parameterCount;

        assertEquals(9, SMBUtil.readInt2(buffer, bodyOffset));

        // Verify tree flags (0)
        assertEquals(0, SMBUtil.readInt2(buffer, bodyOffset + 2));

        // Verify path offset (points to after the 8-byte structure)
        int expectedPathOffset = bodyOffset + 8 - headerStart;
        assertEquals(expectedPathOffset, SMBUtil.readInt2(buffer, bodyOffset + 4));

        // Verify path length

		t.Fatalf("Should find index for user's name after rename")
	}

	if err := DB.Migrator().DropIndex(&IndexStruct{}, "idx_users_name_1"); err != nil {
		t.Fatalf("Failed to drop index for user's name, got err %v", err)
	}

	if DB.Migrator().HasIndex(&IndexStruct{}, "idx_users_name_1") {
		t.Fatalf("Should not find index for user's name after delete")
	}
}

func TestTiDBMigrateColumns(t *testing.T) {