1 files changed, 60 insertions, 61 deletions

diff --git a/document/src/tests/documentupdatetestcase.cpp b/document/src/tests/documentupdatetestcase.cpp
index beb94959e73..40f398ee93e 100644
--- a/document/src/tests/documentupdatetestcase.cpp
+++ b/document/src/tests/documentupdatetestcase.cpp
@@ -120,13 +120,13 @@ TEST(DocumentUpdateTest, testSimpleUsage)
 
         // Test that primitive value updates can be serialized
     testRoundtripSerialize(ClearValueUpdate(), *DataType::INT);
-    testRoundtripSerialize(AssignValueUpdate(IntFieldValue(1)), *DataType::INT);
+    testRoundtripSerialize(AssignValueUpdate(std::make_unique<IntFieldValue>(1)), *DataType::INT);
     testRoundtripSerialize(ArithmeticValueUpdate(ArithmeticValueUpdate::Div, 4.3), *DataType::FLOAT);
-    testRoundtripSerialize(AddValueUpdate(IntFieldValue(1), 4), *arrayType);
-    testRoundtripSerialize(RemoveValueUpdate(IntFieldValue(1)), *arrayType);
+    testRoundtripSerialize(AddValueUpdate(std::make_unique<IntFieldValue>(1), 4), *arrayType);
+    testRoundtripSerialize(RemoveValueUpdate(std::make_unique<IntFieldValue>(1)), *arrayType);
 
     FieldUpdate fieldUpdate(docType->getField("intf"));
-    fieldUpdate.addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(1)));
+    fieldUpdate.addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(1)));
     nbostream stream = serialize(fieldUpdate);
     FieldUpdate fieldUpdateCopy(repo, *docType, stream);
     EXPECT_EQ(fieldUpdate, fieldUpdateCopy);
@@ -158,7 +158,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intf")).addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(15))));
+        upd.addUpdate(FieldUpdate(docType->getField("intf")).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(15))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         EXPECT_EQ(15, updated.getValue("intf")->getAsInt());
@@ -174,7 +174,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(4))));
+        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(4))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         std::unique_ptr<ArrayFieldValue> val(dynamic_cast<ArrayFieldValue*>(updated.getValue("intarr").release()));
@@ -184,7 +184,7 @@ TEST(DocumentUpdateTest, testSimpleUsage)
     {
         Document updated(doc);
         DocumentUpdate upd(repo, *docType, DocumentId("id:ns:test::1"));
-        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<RemoveValueUpdate>(IntFieldValue(3))));
+        upd.addUpdate(FieldUpdate(docType->getField("intarr")).addUpdate(std::make_unique<RemoveValueUpdate>(std::make_unique<IntFieldValue>(3))));
         upd.applyTo(updated);
         EXPECT_NE(doc, updated);
         std::unique_ptr<ArrayFieldValue> val(dynamic_cast<ArrayFieldValue*>(updated.getValue("intarr").release()));
@@ -227,7 +227,7 @@ TEST(DocumentUpdateTest, testUpdateApplySingleValue)
 
     // Apply an update.
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(doc->getField("headerval")).addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(9))))
+        .addUpdate(FieldUpdate(doc->getField("headerval")).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(9))))
         .applyTo(*doc);
     EXPECT_EQ(9, doc->getValue("headerval")->getAsInt());
 }
@@ -240,12 +240,12 @@ TEST(DocumentUpdateTest, testUpdateArray)
     EXPECT_EQ((document::FieldValue*)nullptr, doc->getValue(doc->getField("tags")).get());
 
     // Assign array field.
-    ArrayFieldValue myarray(doc->getType().getField("tags").getDataType());
-    myarray.add(StringFieldValue("foo"));
-	myarray.add(StringFieldValue("bar"));
+    auto myarray = std::make_unique<ArrayFieldValue>(doc->getType().getField("tags").getDataType());
+    myarray->add(StringFieldValue("foo"));
+	myarray->add(StringFieldValue("bar"));
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(doc->getField("tags")).addUpdate(std::make_unique<AssignValueUpdate>(myarray)))
+        .addUpdate(FieldUpdate(doc->getField("tags")).addUpdate(std::make_unique<AssignValueUpdate>(std::move(myarray))))
         .applyTo(*doc);
     auto fval1(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
     ASSERT_EQ((size_t) 2, fval1->size());
@@ -255,8 +255,8 @@ TEST(DocumentUpdateTest, testUpdateArray)
     // Append array field
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(doc->getField("tags"))
-                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue("another")))
-                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue("tag"))))
+                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue::make("another")))
+                   .addUpdate(std::make_unique<AddValueUpdate>(StringFieldValue::make("tag"))))
         .applyTo(*doc);
     std::unique_ptr<ArrayFieldValue>
         fval2(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
@@ -270,15 +270,15 @@ TEST(DocumentUpdateTest, testUpdateArray)
     ASSERT_THROW(
         DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
             .addUpdate(FieldUpdate(doc->getField("tags"))
-                       .addUpdate(std::make_unique<AssignValueUpdate>(StringFieldValue("THROW MEH!"))))
+                       .addUpdate(std::make_unique<AssignValueUpdate>(StringFieldValue::make("THROW MEH!"))))
             .applyTo(*doc),
         std::exception) << "Expected exception when assigning a string value to an array field.";
 
     // Remove array field.
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(doc->getField("tags"))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("foo")))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("tag"))))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue::make("foo")))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue::make("tag"))))
         .applyTo(*doc);
     auto fval3(doc->getAs<ArrayFieldValue>(doc->getField("tags")));
     ASSERT_EQ((size_t) 2, fval3->size());
@@ -286,27 +286,27 @@ TEST(DocumentUpdateTest, testUpdateArray)
     EXPECT_EQ(std::string("another"), std::string((*fval3)[1].getAsString()));
 
     // Remove array from array.
-    ArrayFieldValue myarray2(doc->getType().getField("tags").getDataType());
-    myarray2.add(StringFieldValue("foo"));
-    myarray2.add(StringFieldValue("bar"));
+    auto myarray2 = std::make_unique<ArrayFieldValue>(doc->getType().getField("tags").getDataType());
+    myarray2->add(StringFieldValue("foo"));
+    myarray2->add(StringFieldValue("bar"));
     ASSERT_THROW(
         DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
             .addUpdate(FieldUpdate(doc->getField("tags"))
-                       .addUpdate(std::make_unique<RemoveValueUpdate>(myarray2)))
+                       .addUpdate(std::make_unique<RemoveValueUpdate>(std::move(myarray2))))
             .applyTo(*doc),
         std::exception) << "Expected exception when removing an array from a string array.";
 }
 
 std::unique_ptr<ValueUpdate>
 createAddUpdate(vespalib::stringref key, int weight) {
-    auto upd = std::make_unique<AddValueUpdate>(StringFieldValue(key));
+    auto upd = std::make_unique<AddValueUpdate>(StringFieldValue::make(key));
     upd->setWeight(weight);
     return upd;
 }
 
 std::unique_ptr<ValueUpdate>
 createAddUpdate(int key, int weight) {
-    auto upd = std::make_unique<AddValueUpdate>(IntFieldValue(key));
+    auto upd = std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(key));
     upd->setWeight(weight);
     return upd;
 }
@@ -320,11 +320,11 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     EXPECT_EQ((FieldValue*) 0, doc->getValue(field).get());
 	
     // Assign weightedset field
-    WeightedSetFieldValue wset(field.getDataType());
-    wset.add(StringFieldValue("foo"), 3);
-    wset.add(StringFieldValue("bar"), 14);
+    auto wset =std::make_unique<WeightedSetFieldValue>(field.getDataType());
+    wset->add(StringFieldValue("foo"), 3);
+    wset->add(StringFieldValue("bar"), 14);
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
-        .addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(wset)))
+        .addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::move(wset))))
         .applyTo(*doc);
     auto fval1(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 2, fval1->size());
@@ -336,12 +336,12 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     EXPECT_EQ(14, fval1->get(StringFieldValue("bar"), 0));
 
     // Do a second assign
-    WeightedSetFieldValue wset2(field.getDataType());
-    wset2.add(StringFieldValue("foo"), 16);
-    wset2.add(StringFieldValue("bar"), 24);
+    auto wset2 = std::make_unique<WeightedSetFieldValue>(field.getDataType());
+    wset2->add(StringFieldValue("foo"), 16);
+    wset2->add(StringFieldValue("bar"), 24);
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field)
-                   .addUpdate(std::make_unique<AssignValueUpdate>(wset2)))
+                   .addUpdate(std::make_unique<AssignValueUpdate>(std::move(wset2))))
         .applyTo(*doc);
     auto fval2(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 2, fval2->size());
@@ -371,8 +371,8 @@ TEST(DocumentUpdateTest, testUpdateWeightedSet)
     // Remove weighted field
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field)
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("foo")))
-                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue("too"))))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue::make("foo")))
+                   .addUpdate(std::make_unique<RemoveValueUpdate>(StringFieldValue::make("too"))))
         .applyTo(*doc);
     auto fval4(doc->getAs<WeightedSetFieldValue>(field));
     ASSERT_EQ((size_t) 1, fval4->size());
@@ -419,7 +419,7 @@ WeightedSetAutoCreateFixture::WeightedSetAutoCreateFixture()
       update(repo, *docType, DocumentId("id:ns:test::1"))
 {
     update.addUpdate(FieldUpdate(field)
-                             .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+                             .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("foo"),
                                                        std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1))));
 }
 } // anon ns
@@ -457,7 +457,7 @@ TEST(DocumentUpdateTest, testIncrementWithZeroResultWeightIsRemoved)
 {
     WeightedSetAutoCreateFixture fixture;
     fixture.update.addUpdate(FieldUpdate(fixture.field)
-            .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("baz"),
+            .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("baz"),
                                       std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 0))));
 
     fixture.applyUpdateToDocument();
@@ -498,7 +498,7 @@ TEST(DocumentUpdateTest, testReadSerializedFile)
 
     serValue = &serField2[0];
     EXPECT_EQ(serValue->getType(), ValueUpdate::Clear);
-    EXPECT_TRUE(serValue->inherits(ClearValueUpdate::classId));
+    EXPECT_EQ(ValueUpdate::Clear, serValue->getType());
 
     // Verify add value update.
     const FieldUpdate & serField3 = upd.getUpdates()[0];
@@ -539,19 +539,19 @@ TEST(DocumentUpdateTest, testGenerateSerializedFile)
     const DocumentType *type(repo.getDocumentType("serializetest"));
     DocumentUpdate upd(repo, *type, DocumentId("id:ns:serializetest::update"));
     upd.addUpdate(FieldUpdate(type->getField("intfield"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(4))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(4))));
     upd.addUpdate(FieldUpdate(type->getField("floatfield"))
-		  .addUpdate(std::make_unique<AssignValueUpdate>(FloatFieldValue(1.00f))));
+		  .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<FloatFieldValue>(1.00f))));
     upd.addUpdate(FieldUpdate(type->getField("arrayoffloatfield"))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(5.00f)))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(4.23f)))
-		  .addUpdate(std::make_unique<AddValueUpdate>(FloatFieldValue(-1.00f))));
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(5.00f)))
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(4.23f)))
+		  .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<FloatFieldValue>(-1.00f))));
     upd.addUpdate(FieldUpdate(type->getField("intfield"))
           .addUpdate(std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 3)));
     upd.addUpdate(FieldUpdate(type->getField("wsfield"))
-          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("foo"),
                         std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 2)))
-          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("foo"),
+          .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("foo"),
                         std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Mul, 2))));
     nbostream buf(serializeHEAD(upd));
     writeBufferToFile(buf, "data/serializeupdatecpp.dat");
@@ -569,7 +569,7 @@ TEST(DocumentUpdateTest, testSetBadFieldTypes)
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     ASSERT_THROW(
         update.addUpdate(FieldUpdate(doc->getField("headerval"))
-                 .addUpdate(std::make_unique<AssignValueUpdate>(FloatFieldValue(4.00f)))),
+                 .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<FloatFieldValue>(4.00f)))),
         std::exception) << "Expected exception when adding a float to an int field.";
 
     update.applyTo(*doc);
@@ -604,7 +604,7 @@ TEST(DocumentUpdateTest, testUpdateApplyNoArrayValues)
     // Assign array field with no array values = empty array
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     update.addUpdate(FieldUpdate(field)
-                     .addUpdate(std::make_unique<AssignValueUpdate>(ArrayFieldValue(field.getDataType()))));
+                     .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<ArrayFieldValue>(field.getDataType()))));
 
     update.applyTo(*doc);
 
@@ -624,7 +624,7 @@ TEST(DocumentUpdateTest, testUpdateArrayEmptyParamValue)
 
     // Assign array field with no array values = empty array.
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
-    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(ArrayFieldValue(field.getDataType()))));
+    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<ArrayFieldValue>(field.getDataType()))));
     update.applyTo(*doc);
 
     // Verify that the field was set in the document.
@@ -652,7 +652,7 @@ TEST(DocumentUpdateTest, testUpdateWeightedSetEmptyParamValue)
 
     // Assign weighted set with no items = empty set.
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
-    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(WeightedSetFieldValue(field.getDataType()))));
+    update.addUpdate(FieldUpdate(field).addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<WeightedSetFieldValue>(field.getDataType()))));
     update.applyTo(*doc);
 
     // Verify that the field was set in the document.
@@ -682,8 +682,8 @@ TEST(DocumentUpdateTest, testUpdateArrayWrongSubtype)
     DocumentUpdate update(docMan.getTypeRepo(), *doc->getDataType(), doc->getId());
     ASSERT_THROW(
         update.addUpdate(FieldUpdate(field)
-                 .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(123)))
-                 .addUpdate(std::make_unique<AddValueUpdate>(IntFieldValue(456)))),
+                 .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(123)))
+                 .addUpdate(std::make_unique<AddValueUpdate>(std::make_unique<IntFieldValue>(456)))),
         std::exception) << "Expected exception when adding wrong type.";
 
     // Apply update
@@ -732,7 +732,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field1)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("banana"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("banana"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1.0))))
         .applyTo(*doc);
     std::unique_ptr<WeightedSetFieldValue> fv1 =
@@ -741,7 +741,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field2)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("banana"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("banana"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Add, 1.0))))
         .applyTo(*doc);
     auto fv2 = doc->getAs<WeightedSetFieldValue>(field2);
@@ -770,7 +770,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field1)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("apple"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("apple"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Sub, 1.0))))
         .applyTo(*doc);
 
@@ -780,7 +780,7 @@ TEST(DocumentUpdateTest, testMapValueUpdate)
 
     DocumentUpdate(docMan.getTypeRepo(), *doc->getDataType(), doc->getId())
         .addUpdate(FieldUpdate(field2)
-                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue("apple"),
+                   .addUpdate(std::make_unique<MapValueUpdate>(StringFieldValue::make("apple"),
                                              std::make_unique<ArithmeticValueUpdate>(ArithmeticValueUpdate::Sub, 1.0))))
         .applyTo(*doc);
 
@@ -940,10 +940,9 @@ struct TensorUpdateFixture {
 TEST(DocumentUpdateTest, tensor_assign_update_can_be_applied)
 {
     TensorUpdateFixture f;
-    auto newTensor = f.makeBaselineTensor();
-    f.applyUpdate(std::make_unique<AssignValueUpdate>(*newTensor));
+    f.applyUpdate(std::make_unique<AssignValueUpdate>(f.makeBaselineTensor()));
     f.assertDocumentUpdated();
-    f.assertTensor(*newTensor);
+    f.assertTensor(*f.makeBaselineTensor());
 }
 
 TEST(DocumentUpdateTest, tensor_clear_update_can_be_applied)
@@ -1032,7 +1031,7 @@ TEST(DocumentUpdateTest, tensor_modify_update_can_be_applied_to_nonexisting_tens
 TEST(DocumentUpdateTest, tensor_assign_update_can_be_roundtrip_serialized)
 {
     TensorUpdateFixture f;
-    f.assertRoundtripSerialize(AssignValueUpdate(*f.makeBaselineTensor()));
+    f.assertRoundtripSerialize(AssignValueUpdate(f.makeBaselineTensor()));
 }
 
 TEST(DocumentUpdateTest, tensor_add_update_can_be_roundtrip_serialized)
@@ -1162,7 +1161,7 @@ struct TensorUpdateSerializeFixture {
                 (*repo, docType, DocumentId("id:test:test::0"));
 
         result->addUpdate(FieldUpdate(getField("sparse_tensor"))
-                                  .addUpdate(std::make_unique<AssignValueUpdate>(*makeTensor()))
+                                  .addUpdate(std::make_unique<AssignValueUpdate>(makeTensor()))
                                   .addUpdate(std::make_unique<TensorAddUpdate>(makeTensor()))
                                   .addUpdate(std::make_unique<TensorRemoveUpdate>(makeTensor())));
         result->addUpdate(FieldUpdate(getField("dense_tensor"))
@@ -1250,7 +1249,7 @@ CreateIfNonExistentFixture::CreateIfNonExistentFixture()
       update(std::make_unique<DocumentUpdate>(docMan.getTypeRepo(), *document->getDataType(), document->getId()))
 {
     update->addUpdate(FieldUpdate(document->getField("headerval"))
-                              .addUpdate(std::make_unique<AssignValueUpdate>(IntFieldValue(1))));
+                              .addUpdate(std::make_unique<AssignValueUpdate>(std::make_unique<IntFieldValue>(1))));
     update->setCreateIfNonExistent(true);
 }
 
@@ -1282,8 +1281,8 @@ ArrayUpdateFixture::ArrayUpdateFixture()
 {
     update = std::make_unique<DocumentUpdate>(doc_man.getTypeRepo(), *doc->getDataType(), doc->getId());
     update->addUpdate(FieldUpdate(array_field)
-                              .addUpdate(std::make_unique<MapValueUpdate>(IntFieldValue(1),
-                                                        std::make_unique<AssignValueUpdate>(StringFieldValue("bar")))));
+                              .addUpdate(std::make_unique<MapValueUpdate>(std::make_unique<IntFieldValue>(1),
+                                                        std::make_unique<AssignValueUpdate>(StringFieldValue::make("bar")))));
 }
 ArrayUpdateFixture::~ArrayUpdateFixture() = default;