Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.block;
 
 
 import java.util.List;
 
 import static com.facebook.presto.spi.type.BigintType.BIGINT;
 import static com.facebook.presto.spi.type.BooleanType.BOOLEAN;
 import static com.facebook.presto.spi.type.DoubleType.DOUBLE;
 import static com.facebook.presto.spi.type.TimeZoneKey.UTC_KEY;
 import static com.facebook.presto.spi.type.VarcharType.VARCHAR;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static java.util.Locale.ENGLISH;
 import static org.testng.Assert.assertEquals;
 
 public final class BlockAssertions
 {
     public static final ConnectorSession SESSION = new ConnectorSession("user", System.currentTimeMillis(), null);
 
     private BlockAssertions()
     {
     }
 
     public static Object getOnlyValue(Type typeBlock block)
     {
         assertEquals(block.getPositionCount(), 1, "Block positions");
         return type.getObjectValue(block, 0);
     }
 
     public static List<ObjecttoValues(Type typeIterable<Blockblocks)
     {
         List<Objectvalues = new ArrayList<>();
         for (Block block : blocks) {
             for (int position = 0; position < block.getPositionCount(); position++) {
                 values.add(type.getObjectValue(blockposition));
             }
         }
         return Collections.unmodifiableList(values);
     }
 
     public static List<ObjecttoValues(Type typeBlock block)
     {
         List<Objectvalues = new ArrayList<>();
         for (int position = 0; position < block.getPositionCount(); position++) {
             values.add(type.getObjectValue(blockposition));
         }
         return Collections.unmodifiableList(values);
     }
 
     public static void assertBlockEquals(Type typeBlock actualBlock expected)
     {
         for (int position = 0; position < actual.getPositionCount(); position++) {
             assertEquals(type.getObjectValue(actualposition), type.getObjectValue(expectedposition));
         }
     }
 
     public static Block createStringsBlock(String... values)
     {
         checkNotNull(values"varargs 'values' is null");
 
         return createStringsBlock(Arrays.asList(values));
     }
 
     public static Block createStringsBlock(Iterable<Stringvalues)
     {
         BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
 
         for (String value : values) {
             if (value == null) {
                 builder.appendNull();
             }
             else {
                 .writeString(buildervalue);
             }
         }
 
         return builder.build();
     }
 
    public static Block createStringSequenceBlock(int startint end)
    {
        BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
        for (int i = starti < endi++) {
            .writeString(builder, String.valueOf(i));
        }
        return builder.build();
    }
    public static Block createBooleansBlock(Boolean... values)
    {
        checkNotNull(values"varargs 'values' is null");
        return createBooleansBlock(Arrays.asList(values));
    }
    public static Block createBooleansBlock(Boolean valueint count)
    {
        return createBooleansBlock(Collections.nCopies(countvalue));
    }
    public static Block createBooleansBlock(Iterable<Booleanvalues)
    {
        BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
        for (Boolean value : values) {
            if (value == null) {
                builder.appendNull();
            }
            else {
                .writeBoolean(buildervalue);
            }
        }
        return builder.build();
    }
    // This method makes it easy to create blocks without having to add an L to every value
    public static Block createLongsBlock(int... values)
    {
        BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
        for (int value : values) {
            .writeLong(builder, (longvalue);
        }
        return builder.build();
    }
    public static Block createLongsBlock(Long... values)
    {
        checkNotNull(values"varargs 'values' is null");
        return createLongsBlock(Arrays.asList(values));
    }
    public static Block createLongsBlock(Iterable<Longvalues)
    {
        BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
        for (Long value : values) {
            if (value == null) {
                builder.appendNull();
            }
            else {
                .writeLong(buildervalue);
            }
        }
        return builder.build();
    }
    public static Block createLongSequenceBlock(int startint end)
    {
        BlockBuilder builder = .createFixedSizeBlockBuilder(end - start);
        for (int i = starti < endi++) {
            .writeLong(builderi);
        }
        return builder.build();
    }
    public static Block createBooleanSequenceBlock(int startint end)
    {
        BlockBuilder builder = .createFixedSizeBlockBuilder(end - start);
        for (int i = starti < endi++) {
            .writeBoolean(builderi % 2 == 0);
        }
        return builder.build();
    }
    public static Block createDoublesBlock(Double... values)
    {
        checkNotNull(values"varargs 'values' is null");
        return createDoublesBlock(Arrays.asList(values));
    }
    public static Block createDoublesBlock(Iterable<Doublevalues)
    {
        BlockBuilder builder = .createBlockBuilder(new BlockBuilderStatus(), 100);
        for (Double value : values) {
            if (value == null) {
                builder.appendNull();
            }
            else {
                .writeDouble(buildervalue);
            }
        }
        return builder.build();
    }
    public static Block createDoubleSequenceBlock(int startint end)
    {
        BlockBuilder builder = .createFixedSizeBlockBuilder(end - start);
        for (int i = starti < endi++) {
            .writeDouble(builder, (doublei);
        }
        return builder.build();
    }
New to GrepCode? Check out our FAQ X