tests/autofillservice/src/android/autofillservice/cts/unittests/DatasetTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * 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 android.autofillservice.cts.unittests;

 import static com.google.common.truth.Truth.assertThat;

 import static org.mockito.Mockito.mock;
 import static org.testng.Assert.assertThrows;

 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;

 import android.app.slice.Slice;
 import android.app.slice.SliceSpec;
 import android.content.ClipData;
 import android.content.Intent;
 import android.content.IntentSender;
 import android.net.Uri;
 import android.os.Parcel;
 import android.platform.test.annotations.AppModeFull;
 import android.service.autofill.Dataset;
 import android.service.autofill.Field;
 import android.service.autofill.InlinePresentation;
 import android.service.autofill.Presentations;
 import android.util.Size;
 import android.view.autofill.AutofillId;
 import android.view.autofill.AutofillValue;
 import android.widget.RemoteViews;
 import android.widget.inline.InlinePresentationSpec;

 import androidx.test.ext.junit.runners.AndroidJUnit4;

 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.util.regex.Pattern;

 @RunWith(AndroidJUnit4.class)
 @AppModeFull(reason = "Unit test")
 public class DatasetTest {

     private final AutofillId mId = new AutofillId(42);
     private final AutofillId mId2 = new AutofillId(43);
     private final AutofillValue mValue = AutofillValue.forText("ValuableLikeGold");
     private final Pattern mFilter = Pattern.compile("whatever");
     private final InlinePresentation mInlinePresentation = new InlinePresentation(
             new Slice.Builder(new Uri.Builder().appendPath("DatasetTest").build(),
                     new SliceSpec("DatasetTest", 1)).build(),
             new InlinePresentationSpec.Builder(new Size(10, 10),
                     new Size(50, 50)).build(), /* pinned= */ false);
     private final ClipData mContent = new ClipData("sample label", new String[] {"image/png"},
             new ClipData.Item("content://example/0"));
     private final IntentSender mAuth = mock(IntentSender.class);

     private final RemoteViews mPresentation = mock(RemoteViews.class);
     private final RemoteViews mDialogPresentation = mock(RemoteViews.class);
     private final InlinePresentation mTooltipPresentation = new InlinePresentation(
             new Slice.Builder(new Uri.Builder().appendPath("DatasetTest").build(),
                     new SliceSpec("DatasetTest", 1)).build(),
             new InlinePresentationSpec.Builder(new Size(10, 10),
                     new Size(50, 50)).build(), /* pinned= */ false);
     @Test
     public void testBuilder_nullPresentation() {
         assertThrows(NullPointerException.class, () -> new Dataset.Builder((RemoteViews) null));
     }

     @Test
     public void testBuilder_nullInlinePresentation() {
         assertThrows(NullPointerException.class,
                 () -> new Dataset.Builder((InlinePresentation) null));
     }

     @Test
     public void testBuilder_validPresentations() {
         assertThat(new Dataset.Builder(mPresentation)).isNotNull();
         assertThat(new Dataset.Builder(mInlinePresentation)).isNotNull();
     }

     @Test
     public void testBuilder_setNullInlinePresentation() {
         final Dataset.Builder builder = new Dataset.Builder(mPresentation);
         assertThrows(NullPointerException.class, () -> builder.setInlinePresentation(null));
     }

     @Test
     public void testBuilder_setInlinePresentation() {
         assertThat(new Dataset.Builder().setInlinePresentation(mInlinePresentation)).isNotNull();
     }

     @Test
     public void testBuilder_setValueNullId() {
         final Dataset.Builder builder = new Dataset.Builder(mPresentation);
         assertThrows(NullPointerException.class, () -> builder.setValue(null, mValue));
     }

     @Test
     public void testBuilder_setValueWithoutPresentation() {
         // Just assert that it builds without throwing an exception.
         assertThat(new Dataset.Builder().setValue(mId, mValue).build()).isNotNull();
     }

     @Test
     public void testBuilder_setValueWithNullPresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
                 (RemoteViews) null));
     }

     @Test
     public void testBuilder_setValueWithBothPresentation_nullPresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
                 null, mInlinePresentation));
     }

     @Test
     public void testBuilder_setValueWithBothPresentation_nullInlinePresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
                 mPresentation, null));
     }

     @Test
     public void testBuilder_setValueWithBothPresentation_bothNull() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
                 (RemoteViews) null, null));
     }

     @Test
     public void testBuilder_setFilteredValueWithNullFilter() {
         assertThat(new Dataset.Builder(mPresentation).setValue(mId, mValue, (Pattern) null).build())
                 .isNotNull();
     }

     @Test
     public void testBuilder_setFilteredValueWithPresentation_nullFilter() {
         assertThat(new Dataset.Builder().setValue(mId, mValue, null, mPresentation).build())
                 .isNotNull();
     }

     @Test
     public void testBuilder_setFilteredValueWithPresentation_nullPresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
                 null));
     }

     @Test
     public void testBuilder_setFilteredValueWithoutPresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(IllegalStateException.class, () -> builder.setValue(mId, mValue, mFilter));
     }

     @Test
     public void testBuilder_setFilteredValueWithBothPresentation_nullPresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
                 null, mInlinePresentation));
     }

     @Test
     public void testBuilder_setFilteredValueWithBothPresentation_nullInlinePresentation() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
                 mPresentation, null));
     }

     @Test
     public void testBuilder_setFilteredValueWithBothPresentation_bothNull() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
                 null, null));
     }

     @Test
     public void testBuilder_setFieldInlinePresentations() {
         assertThat(new Dataset.Builder().setFieldInlinePresentation(mId, mValue, mFilter,
                 mInlinePresentation)).isNotNull();
     }

     @Test
     public void testBuilder_setValue() {
         Dataset.Builder builder = new Dataset.Builder().setValue(mId, mValue);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(mValue));
     }

     @Test
     public void testBuilder_setValueForMultipleFields() {
         Dataset.Builder builder = new Dataset.Builder()
                 .setValue(mId, mValue)
                 .setValue(mId2, mValue);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(asList(mId, mId2));
         assertThat(dataset.getFieldValues()).isEqualTo(asList(mValue, mValue));
     }

     @Test
     public void testBuilder_setValueAcceptsNullValue() {
         // It's valid to pass null value, e.g. when wanting to trigger the auth flow.
         Dataset.Builder builder = new Dataset.Builder().setValue(mId, null);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
     }

     @Test
     public void testBuilder_setValueWithAuthentication() {
         Dataset.Builder builder = new Dataset.Builder()
                 .setValue(mId, mValue)
                 .setAuthentication(mAuth);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(mValue));
         assertThat(dataset.getAuthentication()).isEqualTo(mAuth);
     }

     @Test
     public void testField() {
         final Field.Builder builder = new Field.Builder();
         final Presentations presentations =
                 new Presentations.Builder().setMenuPresentation(mPresentation).build();
         final Field field = builder.setValue(mValue)
                 .setFilter(mFilter)
                 .setPresentations(presentations)
                 .build();

         assertThat(field.getValue()).isEqualTo(mValue);
         assertThat(field.getFilter()).isEqualTo(mFilter);
         assertThat(field.getPresentations()).isEqualTo(presentations);
     }

     @Test
     public void testField_empty() {
         final Field field = new Field.Builder().build();

         assertThat(field.getValue()).isNull();
         assertThat(field.getFilter()).isNull();
         assertThat(field.getPresentations()).isNull();
     }

     @Test
     public void testPresentations() {
         final Presentations presentations = new Presentations.Builder()
                 .setMenuPresentation(mPresentation)
                 .setInlinePresentation(mInlinePresentation)
                 .setInlineTooltipPresentation(mTooltipPresentation)
                 .setDialogPresentation(mDialogPresentation)
                 .build();

         assertThat(presentations.getMenuPresentation()).isEqualTo(mPresentation);
         assertThat(presentations.getInlinePresentation()).isEqualTo(mInlinePresentation);
         assertThat(presentations.getInlineTooltipPresentation()).isEqualTo(mTooltipPresentation);
         assertThat(presentations.getDialogPresentation()).isEqualTo(mDialogPresentation);
     }

     @Test
     public void testPresentations_noPresentation() {
         assertThrows(IllegalStateException.class, () -> new Presentations.Builder().build());
     }

     @Test
     public void testBuilder_setFieldNullId() {
         final Dataset.Builder builder = new Dataset.Builder(mPresentation);
         assertThrows(NullPointerException.class,
                 () -> builder.setField(null, new Field.Builder().build()));
     }

     @Test
     public void testBuilder_setFieldNullField() {
         // Just assert that it builds without throwing an exception.
         assertThat(new Dataset.Builder().setField(mId, null)).isNotNull();
     }

     @Test
     public void testBuilder_setFieldWithEmptyField() {
         // Just assert that it builds without throwing an exception.
         assertThat(new Dataset.Builder().setField(mId, new Field.Builder().build())).isNotNull();
     }

     @Test
     public void testBuilder_setContent() {
         Dataset.Builder builder = new Dataset.Builder().setContent(mId, mContent);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldContent()).isEqualTo(mContent);
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
     }

     @Test
     public void testBuilder_setContentWithIntentIsNotAllowed() {
         Dataset.Builder builder = new Dataset.Builder();
         ClipData clip = ClipData.newIntent("", new Intent());
         assertThrows(IllegalArgumentException.class, () -> builder.setContent(mId, clip));
     }

     @Test
     public void testBuilder_setContentAcceptsNullContent() {
         // It's valid to pass null content, e.g. when wanting to trigger the auth flow.
         Dataset.Builder builder = new Dataset.Builder().setContent(mId, null);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldContent()).isNull();
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
     }

     @Test
     public void testBuilder_setContentWithAuthentication() {
         Dataset.Builder builder = new Dataset.Builder()
                 .setContent(mId, mContent)
                 .setAuthentication(mAuth);
         Dataset dataset = builder.build();
         assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(dataset.getFieldContent()).isEqualTo(mContent);
         assertThat(dataset.getAuthentication()).isEqualTo(mAuth);
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
     }

     @Test
     public void testBuilder_settingBothContentAndValuesIsNotAllowed() {
         // Setting both content and value for the same field is not allowed.
         Dataset.Builder builder = new Dataset.Builder();
         builder.setContent(mId, mContent);
         builder.setValue(mId, mValue);
         assertThrows(IllegalStateException.class, builder::build);

         // Setting both content and value, even if for different fields, is not allowed.
         builder = new Dataset.Builder();
         builder.setContent(mId, mContent);
         builder.setValue(mId2, mValue);
         assertThrows(IllegalStateException.class, builder::build);
     }

     @Test
     public void testBuilder_settingContentForMultipleFieldsIsNotAllowed() {
         Dataset.Builder builder = new Dataset.Builder();
         builder.setContent(mId, mContent);
         builder.setContent(mId2, mContent);
         assertThrows(IllegalStateException.class, builder::build);
     }

     @Test
     public void testBuild_noValues() {
         final Dataset.Builder builder = new Dataset.Builder();
         assertThrows(IllegalStateException.class, () -> builder.build());
     }

     @Test
     public void testNoMoreInteractionsAfterBuild() {
         final Dataset.Builder builder = new Dataset.Builder();
         builder.setValue(mId, mValue, mPresentation);
         assertThat(builder.build()).isNotNull();
         assertThrows(IllegalStateException.class, () -> builder.build());
         assertThrows(IllegalStateException.class,
                 () -> builder.setInlinePresentation(mInlinePresentation));
         assertThrows(IllegalStateException.class, () -> builder.setValue(mId, mValue));
         assertThrows(IllegalStateException.class,
                 () -> builder.setValue(mId, mValue, mPresentation));
         assertThrows(IllegalStateException.class,
                 () -> builder.setValue(mId, mValue, mFilter));
         assertThrows(IllegalStateException.class,
                 () -> builder.setValue(mId, mValue, mFilter, mPresentation));
         assertThrows(IllegalStateException.class,
                 () -> builder.setValue(mId, mValue, mPresentation, mInlinePresentation));
         assertThrows(IllegalStateException.class,
                 () -> builder.setValue(mId, mValue, mFilter, mPresentation, mInlinePresentation));
         assertThrows(IllegalStateException.class,
                 () -> builder.setFieldInlinePresentation(mId, mValue, mFilter,
                         mInlinePresentation));
         assertThrows(IllegalStateException.class, () -> builder.setContent(mId, mContent));
     }

     @Test
     public void testWriteToParcel_values() throws Exception {
         Dataset dataset = new Dataset.Builder(mInlinePresentation)
                 .setValue(mId, mValue)
                 .setValue(mId2, mValue)
                 .setId("test-dataset-id")
                 .build();
         Parcel parcel = Parcel.obtain();
         dataset.writeToParcel(parcel, 0);
         parcel.setDataPosition(0);

         Dataset result = Dataset.CREATOR.createFromParcel(parcel);
         assertThat(result.getId()).isEqualTo(dataset.getId());
         assertThat(result.getFieldIds()).isEqualTo(asList(mId, mId2));
         assertThat(result.getFieldValues()).isEqualTo(asList(mValue, mValue));
         assertThat(result.getFieldContent()).isNull();
     }

     @Test
     public void testWriteToParcel_content() throws Exception {
         Dataset dataset = new Dataset.Builder(mInlinePresentation)
                 .setContent(mId, mContent)
                 .setId("test-dataset-id")
                 .build();
         Parcel parcel = Parcel.obtain();
         dataset.writeToParcel(parcel, 0);
         parcel.setDataPosition(0);

         Dataset result = Dataset.CREATOR.createFromParcel(parcel);
         assertThat(result.getId()).isEqualTo(dataset.getId());
         assertThat(result.getFieldIds()).isEqualTo(singletonList(mId));
         assertThat(result.getFieldContent().getItemCount()).isEqualTo(mContent.getItemCount());
         assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* 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 android.autofillservice.cts.unittests;

	import static com.google.common.truth.Truth.assertThat;

	import static org.mockito.Mockito.mock;
	import static org.testng.Assert.assertThrows;

	import static java.util.Arrays.asList;
	import static java.util.Collections.singletonList;

	import android.app.slice.Slice;
	import android.app.slice.SliceSpec;
	import android.content.ClipData;
	import android.content.Intent;
	import android.content.IntentSender;
	import android.net.Uri;
	import android.os.Parcel;
	import android.platform.test.annotations.AppModeFull;
	import android.service.autofill.Dataset;
	import android.service.autofill.Field;
	import android.service.autofill.InlinePresentation;
	import android.service.autofill.Presentations;
	import android.util.Size;
	import android.view.autofill.AutofillId;
	import android.view.autofill.AutofillValue;
	import android.widget.RemoteViews;
	import android.widget.inline.InlinePresentationSpec;

	import androidx.test.ext.junit.runners.AndroidJUnit4;

	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.util.regex.Pattern;

	@RunWith(AndroidJUnit4.class)
	@AppModeFull(reason = "Unit test")
	public class DatasetTest {

	private final AutofillId mId = new AutofillId(42);
	private final AutofillId mId2 = new AutofillId(43);
	private final AutofillValue mValue = AutofillValue.forText("ValuableLikeGold");
	private final Pattern mFilter = Pattern.compile("whatever");
	private final InlinePresentation mInlinePresentation = new InlinePresentation(
	new Slice.Builder(new Uri.Builder().appendPath("DatasetTest").build(),
	new SliceSpec("DatasetTest", 1)).build(),
	new InlinePresentationSpec.Builder(new Size(10, 10),
	new Size(50, 50)).build(), /* pinned= */ false);
	private final ClipData mContent = new ClipData("sample label", new String[] {"image/png"},
	new ClipData.Item("content://example/0"));
	private final IntentSender mAuth = mock(IntentSender.class);

	private final RemoteViews mPresentation = mock(RemoteViews.class);
	private final RemoteViews mDialogPresentation = mock(RemoteViews.class);
	private final InlinePresentation mTooltipPresentation = new InlinePresentation(
	new Slice.Builder(new Uri.Builder().appendPath("DatasetTest").build(),
	new SliceSpec("DatasetTest", 1)).build(),
	new InlinePresentationSpec.Builder(new Size(10, 10),
	new Size(50, 50)).build(), /* pinned= */ false);
	@Test
	public void testBuilder_nullPresentation() {
	assertThrows(NullPointerException.class, () -> new Dataset.Builder((RemoteViews) null));
	}

	@Test
	public void testBuilder_nullInlinePresentation() {
	assertThrows(NullPointerException.class,
	() -> new Dataset.Builder((InlinePresentation) null));
	}

	@Test
	public void testBuilder_validPresentations() {
	assertThat(new Dataset.Builder(mPresentation)).isNotNull();
	assertThat(new Dataset.Builder(mInlinePresentation)).isNotNull();
	}

	@Test
	public void testBuilder_setNullInlinePresentation() {
	final Dataset.Builder builder = new Dataset.Builder(mPresentation);
	assertThrows(NullPointerException.class, () -> builder.setInlinePresentation(null));
	}

	@Test
	public void testBuilder_setInlinePresentation() {
	assertThat(new Dataset.Builder().setInlinePresentation(mInlinePresentation)).isNotNull();
	}

	@Test
	public void testBuilder_setValueNullId() {
	final Dataset.Builder builder = new Dataset.Builder(mPresentation);
	assertThrows(NullPointerException.class, () -> builder.setValue(null, mValue));
	}

	@Test
	public void testBuilder_setValueWithoutPresentation() {
	// Just assert that it builds without throwing an exception.
	assertThat(new Dataset.Builder().setValue(mId, mValue).build()).isNotNull();
	}

	@Test
	public void testBuilder_setValueWithNullPresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
	(RemoteViews) null));
	}

	@Test
	public void testBuilder_setValueWithBothPresentation_nullPresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
	null, mInlinePresentation));
	}

	@Test
	public void testBuilder_setValueWithBothPresentation_nullInlinePresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
	mPresentation, null));
	}

	@Test
	public void testBuilder_setValueWithBothPresentation_bothNull() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue,
	(RemoteViews) null, null));
	}

	@Test
	public void testBuilder_setFilteredValueWithNullFilter() {
	assertThat(new Dataset.Builder(mPresentation).setValue(mId, mValue, (Pattern) null).build())
	.isNotNull();
	}

	@Test
	public void testBuilder_setFilteredValueWithPresentation_nullFilter() {
	assertThat(new Dataset.Builder().setValue(mId, mValue, null, mPresentation).build())
	.isNotNull();
	}

	@Test
	public void testBuilder_setFilteredValueWithPresentation_nullPresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
	null));
	}

	@Test
	public void testBuilder_setFilteredValueWithoutPresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(IllegalStateException.class, () -> builder.setValue(mId, mValue, mFilter));
	}

	@Test
	public void testBuilder_setFilteredValueWithBothPresentation_nullPresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
	null, mInlinePresentation));
	}

	@Test
	public void testBuilder_setFilteredValueWithBothPresentation_nullInlinePresentation() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
	mPresentation, null));
	}

	@Test
	public void testBuilder_setFilteredValueWithBothPresentation_bothNull() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(NullPointerException.class, () -> builder.setValue(mId, mValue, mFilter,
	null, null));
	}

	@Test
	public void testBuilder_setFieldInlinePresentations() {
	assertThat(new Dataset.Builder().setFieldInlinePresentation(mId, mValue, mFilter,
	mInlinePresentation)).isNotNull();
	}

	@Test
	public void testBuilder_setValue() {
	Dataset.Builder builder = new Dataset.Builder().setValue(mId, mValue);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(mValue));
	}

	@Test
	public void testBuilder_setValueForMultipleFields() {
	Dataset.Builder builder = new Dataset.Builder()
	.setValue(mId, mValue)
	.setValue(mId2, mValue);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(asList(mId, mId2));
	assertThat(dataset.getFieldValues()).isEqualTo(asList(mValue, mValue));
	}

	@Test
	public void testBuilder_setValueAcceptsNullValue() {
	// It's valid to pass null value, e.g. when wanting to trigger the auth flow.
	Dataset.Builder builder = new Dataset.Builder().setValue(mId, null);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
	}

	@Test
	public void testBuilder_setValueWithAuthentication() {
	Dataset.Builder builder = new Dataset.Builder()
	.setValue(mId, mValue)
	.setAuthentication(mAuth);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(mValue));
	assertThat(dataset.getAuthentication()).isEqualTo(mAuth);
	}

	@Test
	public void testField() {
	final Field.Builder builder = new Field.Builder();
	final Presentations presentations =
	new Presentations.Builder().setMenuPresentation(mPresentation).build();
	final Field field = builder.setValue(mValue)
	.setFilter(mFilter)
	.setPresentations(presentations)
	.build();

	assertThat(field.getValue()).isEqualTo(mValue);
	assertThat(field.getFilter()).isEqualTo(mFilter);
	assertThat(field.getPresentations()).isEqualTo(presentations);
	}

	@Test
	public void testField_empty() {
	final Field field = new Field.Builder().build();

	assertThat(field.getValue()).isNull();
	assertThat(field.getFilter()).isNull();
	assertThat(field.getPresentations()).isNull();
	}

	@Test
	public void testPresentations() {
	final Presentations presentations = new Presentations.Builder()
	.setMenuPresentation(mPresentation)
	.setInlinePresentation(mInlinePresentation)
	.setInlineTooltipPresentation(mTooltipPresentation)
	.setDialogPresentation(mDialogPresentation)
	.build();

	assertThat(presentations.getMenuPresentation()).isEqualTo(mPresentation);
	assertThat(presentations.getInlinePresentation()).isEqualTo(mInlinePresentation);
	assertThat(presentations.getInlineTooltipPresentation()).isEqualTo(mTooltipPresentation);
	assertThat(presentations.getDialogPresentation()).isEqualTo(mDialogPresentation);
	}

	@Test
	public void testPresentations_noPresentation() {
	assertThrows(IllegalStateException.class, () -> new Presentations.Builder().build());
	}

	@Test
	public void testBuilder_setFieldNullId() {
	final Dataset.Builder builder = new Dataset.Builder(mPresentation);
	assertThrows(NullPointerException.class,
	() -> builder.setField(null, new Field.Builder().build()));
	}

	@Test
	public void testBuilder_setFieldNullField() {
	// Just assert that it builds without throwing an exception.
	assertThat(new Dataset.Builder().setField(mId, null)).isNotNull();
	}

	@Test
	public void testBuilder_setFieldWithEmptyField() {
	// Just assert that it builds without throwing an exception.
	assertThat(new Dataset.Builder().setField(mId, new Field.Builder().build())).isNotNull();
	}

	@Test
	public void testBuilder_setContent() {
	Dataset.Builder builder = new Dataset.Builder().setContent(mId, mContent);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldContent()).isEqualTo(mContent);
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
	}

	@Test
	public void testBuilder_setContentWithIntentIsNotAllowed() {
	Dataset.Builder builder = new Dataset.Builder();
	ClipData clip = ClipData.newIntent("", new Intent());
	assertThrows(IllegalArgumentException.class, () -> builder.setContent(mId, clip));
	}

	@Test
	public void testBuilder_setContentAcceptsNullContent() {
	// It's valid to pass null content, e.g. when wanting to trigger the auth flow.
	Dataset.Builder builder = new Dataset.Builder().setContent(mId, null);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldContent()).isNull();
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
	}

	@Test
	public void testBuilder_setContentWithAuthentication() {
	Dataset.Builder builder = new Dataset.Builder()
	.setContent(mId, mContent)
	.setAuthentication(mAuth);
	Dataset dataset = builder.build();
	assertThat(dataset.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(dataset.getFieldContent()).isEqualTo(mContent);
	assertThat(dataset.getAuthentication()).isEqualTo(mAuth);
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
	}

	@Test
	public void testBuilder_settingBothContentAndValuesIsNotAllowed() {
	// Setting both content and value for the same field is not allowed.
	Dataset.Builder builder = new Dataset.Builder();
	builder.setContent(mId, mContent);
	builder.setValue(mId, mValue);
	assertThrows(IllegalStateException.class, builder::build);

	// Setting both content and value, even if for different fields, is not allowed.
	builder = new Dataset.Builder();
	builder.setContent(mId, mContent);
	builder.setValue(mId2, mValue);
	assertThrows(IllegalStateException.class, builder::build);
	}

	@Test
	public void testBuilder_settingContentForMultipleFieldsIsNotAllowed() {
	Dataset.Builder builder = new Dataset.Builder();
	builder.setContent(mId, mContent);
	builder.setContent(mId2, mContent);
	assertThrows(IllegalStateException.class, builder::build);
	}

	@Test
	public void testBuild_noValues() {
	final Dataset.Builder builder = new Dataset.Builder();
	assertThrows(IllegalStateException.class, () -> builder.build());
	}

	@Test
	public void testNoMoreInteractionsAfterBuild() {
	final Dataset.Builder builder = new Dataset.Builder();
	builder.setValue(mId, mValue, mPresentation);
	assertThat(builder.build()).isNotNull();
	assertThrows(IllegalStateException.class, () -> builder.build());
	assertThrows(IllegalStateException.class,
	() -> builder.setInlinePresentation(mInlinePresentation));
	assertThrows(IllegalStateException.class, () -> builder.setValue(mId, mValue));
	assertThrows(IllegalStateException.class,
	() -> builder.setValue(mId, mValue, mPresentation));
	assertThrows(IllegalStateException.class,
	() -> builder.setValue(mId, mValue, mFilter));
	assertThrows(IllegalStateException.class,
	() -> builder.setValue(mId, mValue, mFilter, mPresentation));
	assertThrows(IllegalStateException.class,
	() -> builder.setValue(mId, mValue, mPresentation, mInlinePresentation));
	assertThrows(IllegalStateException.class,
	() -> builder.setValue(mId, mValue, mFilter, mPresentation, mInlinePresentation));
	assertThrows(IllegalStateException.class,
	() -> builder.setFieldInlinePresentation(mId, mValue, mFilter,
	mInlinePresentation));
	assertThrows(IllegalStateException.class, () -> builder.setContent(mId, mContent));
	}

	@Test
	public void testWriteToParcel_values() throws Exception {
	Dataset dataset = new Dataset.Builder(mInlinePresentation)
	.setValue(mId, mValue)
	.setValue(mId2, mValue)
	.setId("test-dataset-id")
	.build();
	Parcel parcel = Parcel.obtain();
	dataset.writeToParcel(parcel, 0);
	parcel.setDataPosition(0);

	Dataset result = Dataset.CREATOR.createFromParcel(parcel);
	assertThat(result.getId()).isEqualTo(dataset.getId());
	assertThat(result.getFieldIds()).isEqualTo(asList(mId, mId2));
	assertThat(result.getFieldValues()).isEqualTo(asList(mValue, mValue));
	assertThat(result.getFieldContent()).isNull();
	}

	@Test
	public void testWriteToParcel_content() throws Exception {
	Dataset dataset = new Dataset.Builder(mInlinePresentation)
	.setContent(mId, mContent)
	.setId("test-dataset-id")
	.build();
	Parcel parcel = Parcel.obtain();
	dataset.writeToParcel(parcel, 0);
	parcel.setDataPosition(0);

	Dataset result = Dataset.CREATOR.createFromParcel(parcel);
	assertThat(result.getId()).isEqualTo(dataset.getId());
	assertThat(result.getFieldIds()).isEqualTo(singletonList(mId));
	assertThat(result.getFieldContent().getItemCount()).isEqualTo(mContent.getItemCount());
	assertThat(dataset.getFieldValues()).isEqualTo(singletonList(null));
	}
	}