Revert the giant layout diff

2026-05-12 16:23:08 +08:00 · 2016-09-14 11:03:21 -07:00
parent 025af5d594
commit a4b6942f00
109 changed files with 1322 additions and 2087 deletions
--- a/AsyncDisplayKitTests/ASBackgroundLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASBackgroundLayoutSpecSnapshotTests.mm
@@ -24,7 +24,8 @@ static const ASSizeRange kSize = {{320, 320}, {320, 320}};
 - (void)testBackground
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor blackColor], {20, 20});
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor blackColor]);
+  foregroundNode.staticSize = {20, 20};
  
  ASLayoutSpec *layoutSpec =
  [ASBackgroundLayoutSpec
--- a/AsyncDisplayKitTests/ASCenterLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASCenterLayoutSpecSnapshotTests.mm
@@ -45,16 +45,10 @@ static const ASSizeRange kSize = {{100, 120}, {320, 160}};
                   sizingOptions:(ASCenterLayoutSpecSizingOptions)sizingOptions
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], CGSizeMake(70, 100));
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+  foregroundNode.staticSize = {70, 100};

-  ASLayoutSpec *layoutSpec =
-  [ASBackgroundLayoutSpec
-   backgroundLayoutSpecWithChild:
-   [ASCenterLayoutSpec
-    centerLayoutSpecWithCenteringOptions:options
-    sizingOptions:sizingOptions
-    child:foregroundNode]
-   background:backgroundNode];
+  ASLayoutSpec *layoutSpec = [ASBackgroundLayoutSpec backgroundLayoutSpecWithChild:[ASCenterLayoutSpec centerLayoutSpecWithCenteringOptions:options sizingOptions:sizingOptions child:foregroundNode]background:backgroundNode];

  [self testLayoutSpec:layoutSpec
             sizeRange:kSize
@@ -89,23 +83,11 @@ static NSString *suffixForCenteringOptions(ASCenterLayoutSpecCenteringOptions ce
 - (void)testMinimumSizeRangeIsGivenToChildWhenNotCentering
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor], CGSizeMake(10, 10));
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  foregroundNode.staticSize = {10, 10};
  foregroundNode.flexGrow = YES;
  
-  ASCenterLayoutSpec *layoutSpec =
-  [ASCenterLayoutSpec
-   centerLayoutSpecWithCenteringOptions:ASCenterLayoutSpecCenteringNone
-   sizingOptions:{}
-   child:
-   [ASBackgroundLayoutSpec
-    backgroundLayoutSpecWithChild:
-    [ASStackLayoutSpec
-     stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical
-     spacing:0
-     justifyContent:ASStackLayoutJustifyContentStart
-     alignItems:ASStackLayoutAlignItemsStart
-     children:@[foregroundNode]]
-    background:backgroundNode]];
+  ASCenterLayoutSpec *layoutSpec = [ASCenterLayoutSpec centerLayoutSpecWithCenteringOptions:ASCenterLayoutSpecCenteringNone sizingOptions:{} child:[ASBackgroundLayoutSpec backgroundLayoutSpecWithChild:[ASStackLayoutSpec stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical spacing:0 justifyContent:ASStackLayoutJustifyContentStart alignItems:ASStackLayoutAlignItemsStart children:@[foregroundNode]] background:backgroundNode]];

  [self testLayoutSpec:layoutSpec sizeRange:kSize subnodes:@[backgroundNode, foregroundNode] identifier:nil];
 }
--- a/AsyncDisplayKitTests/ASDisplayNodeImplicitHierarchyTests.m
+++ b/AsyncDisplayKitTests/ASDisplayNodeImplicitHierarchyTests.m
@@ -78,7 +78,7 @@
    
    return [ASStaticLayoutSpec staticLayoutSpecWithChildren:@[stack1, stack2, node5]];
  };
-  [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+  [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];
  XCTAssertEqual(node.subnodes[0], node5);
  XCTAssertEqual(node.subnodes[1], node1);
  XCTAssertEqual(node.subnodes[2], node2);
@@ -105,13 +105,13 @@
    }
  };
  
-  [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+  [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];
  XCTAssertEqual(node.subnodes[0], node1);
  XCTAssertEqual(node.subnodes[1], node2);
  
  node.layoutState = @2;
  [node invalidateCalculatedLayout];
-  [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+  [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];

  XCTAssertEqual(node.subnodes[0], node1);
  XCTAssertEqual(node.subnodes[1], node3);
@@ -173,12 +173,12 @@
  
  dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    
-    [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+    [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];
    XCTAssertEqual(node.subnodes[0], node1);
    
    node.layoutState = @2;
    [node invalidateCalculatedLayout];
-    [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+    [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];
    
    // Dispatch back to the main thread to let the insertion / deletion of subnodes happening
    dispatch_async(dispatch_get_main_queue(), ^{
@@ -218,7 +218,7 @@
  
  XCTestExpectation *expectation = [self expectationWithDescription:@"Fix IHM layout transition also if one node is already loaded"];
  
-  [node layoutThatFits:ASSizeRangeMake(CGSizeZero)];
+  [node measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeZero)];
  XCTAssertEqual(node.subnodes[0], node1);
  
  node.layoutState = @2;
--- a/AsyncDisplayKitTests/ASDisplayNodeLayoutTests.mm
+++ b/AsyncDisplayKitTests/ASDisplayNodeLayoutTests.mm
@@ -22,9 +22,8 @@
 {
  CGSize nodeSize = CGSizeMake(100, 100);
  
-  ASDisplayNode *displayNode = [[ASDisplayNode alloc] init];
-  displayNode.width = ASDimensionMake(100);
-  displayNode.height = ASDimensionMake(100);
+  ASStaticSizeDisplayNode *displayNode = [ASStaticSizeDisplayNode new];
+  displayNode.staticSize  = nodeSize;
  
  // Use a button node in here as ASButtonNode uses layoutSpecThatFits:
  ASButtonNode *buttonNode = [ASButtonNode new];
@@ -44,6 +43,31 @@
  ASXCTAssertEqualSizes(buttonNode.calculatedSize, nodeSize, @"Automatic measurement pass should have happened in layout pass");
 }

+- (void)testMeasureOnLayoutIfNotHappenedBeforeForRangeManagedNodes
+{
+  CGSize nodeSize = CGSizeMake(100, 100);
+  
+  ASStaticSizeDisplayNode *displayNode = [ASStaticSizeDisplayNode new];
+  displayNode.staticSize  = nodeSize;
+  
+  ASButtonNode *buttonNode = [ASButtonNode new];
+  [displayNode addSubnode:buttonNode];
+  
+  [displayNode enterHierarchyState:ASHierarchyStateRangeManaged];
+  
+  displayNode.frame = {.size = nodeSize};
+  buttonNode.frame = {.size = nodeSize};
+  
+  ASXCTAssertEqualSizes(displayNode.calculatedSize, CGSizeZero, @"Calculated size before measurement and layout should be 0");
+  ASXCTAssertEqualSizes(buttonNode.calculatedSize, CGSizeZero, @"Calculated size before measurement and layout should be 0");
+  
+  // Trigger layout pass without a maeasurment pass before
+  [displayNode.view layoutIfNeeded];
+  
+  ASXCTAssertEqualSizes(displayNode.calculatedSize, nodeSize, @"Automatic measurement pass should have happened in layout pass");
+  ASXCTAssertEqualSizes(buttonNode.calculatedSize, nodeSize, @"Automatic measurement pass should have happened in layout pass");
+}
+
 #if DEBUG
 - (void)testNotAllowAddingSubnodesInLayoutSpecThatFits
 {
@@ -55,7 +79,7 @@
    return [ASInsetLayoutSpec insetLayoutSpecWithInsets:UIEdgeInsetsZero child:someOtherNode];
  };
  
-  XCTAssertThrows([displayNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))], @"Should throw if subnode was added in layoutSpecThatFits:");
+  XCTAssertThrows([displayNode measure:CGSizeMake(100, 100)], @"Should throw if subnode was added in layoutSpecThatFits:");
 }

 - (void)testNotAllowModifyingSubnodesInLayoutSpecThatFits
@@ -71,7 +95,7 @@
    return [ASInsetLayoutSpec insetLayoutSpecWithInsets:UIEdgeInsetsZero child:someOtherNode];
  };
  
-  XCTAssertThrows([displayNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))], @"Should throw if subnodes where modified in layoutSpecThatFits:");
+  XCTAssertThrows([displayNode measure:CGSizeMake(100, 100)], @"Should throw if subnodes where modified in layoutSpecThatFits:");
 }
 #endif

@@ -79,8 +103,8 @@
 {
  CGSize nodeSize = CGSizeMake(100, 100);
  
-  ASDisplayNode *displayNode = [ASDisplayNode new];
-  [displayNode setSizeWithCGSize:nodeSize];
+  ASStaticSizeDisplayNode *displayNode = [ASStaticSizeDisplayNode new];
+  displayNode.staticSize  = nodeSize;
  
  ASButtonNode *buttonNode = [ASButtonNode new];
  [displayNode addSubnode:buttonNode];
@@ -97,7 +121,7 @@
  [displayNode.view layoutIfNeeded];
  XCTAssertEqual(numberOfLayoutSpecThatFitsCalls, 1, @"Should measure during layout if not measured");
  
-  [displayNode layoutThatFits:ASSizeRangeMake(nodeSize, nodeSize)];
+  [displayNode measureWithSizeRange:ASSizeRangeMake(nodeSize, nodeSize)];
  XCTAssertEqual(numberOfLayoutSpecThatFitsCalls, 1, @"Should not remeasure with same bounds");
 }

--- a/AsyncDisplayKitTests/ASDisplayNodeSnapshotTests.m
+++ b/AsyncDisplayKitTests/ASDisplayNodeSnapshotTests.m
@@ -28,7 +28,7 @@
  node.layoutSpecBlock = ^(ASDisplayNode * _Nonnull node, ASSizeRange constrainedSize) {
    return [ASInsetLayoutSpec insetLayoutSpecWithInsets:UIEdgeInsetsMake(5, 5, 5, 5) child:subnode];
  };
-  [node layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))];
+  [node measure:CGSizeMake(100, 100)];

  ASSnapshotVerifyNode(node, nil);
 }
--- a/AsyncDisplayKitTests/ASDisplayNodeTests.m
+++ b/AsyncDisplayKitTests/ASDisplayNodeTests.m
@@ -1991,7 +1991,7 @@ static bool stringContainsPointer(NSString *description, id p) {
 - (void)testThatItsSafeToAutomeasureANodeMidTransition
 {
  ASDisplayNode *supernode = [[ASDisplayNode alloc] init];
-  [supernode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))];
+  [supernode measure:CGSizeMake(100, 100)];
  ASDisplayNode *node = [[ASDisplayNode alloc] init];
  node.bounds = CGRectMake(0, 0, 50, 50);
  [supernode addSubnode:node];
--- a/AsyncDisplayKitTests/ASEditableTextNodeTests.m
+++ b/AsyncDisplayKitTests/ASEditableTextNodeTests.m
@@ -11,7 +11,6 @@
 //

 #import <XCTest/XCTest.h>
-#import <AsyncDisplayKit/ASLayout.h>
 #import <AsyncDisplayKit/ASEditableTextNode.h>

 static BOOL CGSizeEqualToSizeWithIn(CGSize size1, CGSize size2, CGFloat delta)
@@ -139,11 +138,23 @@ static BOOL CGSizeEqualToSizeWithIn(CGSize size1, CGSize size2, CGFloat delta)
  XCTAssertTrue(secureEditableTextNode.textView.secureTextEntry == YES,                                @"textView's isSecureTextEntry should be YES.");
 }

+- (void)testSetPreferredFrameSize
+{
+  CGSize preferredFrameSize = CGSizeMake(100, 100);
+  _editableTextNode.preferredFrameSize = preferredFrameSize;
+  
+  CGSize calculatedSize = [_editableTextNode measure:CGSizeZero];
+  XCTAssertTrue(calculatedSize.width != preferredFrameSize.width, @"Calculated width (%f) should be equal to preferred width (%f)", calculatedSize.width, preferredFrameSize.width);
+  XCTAssertTrue(calculatedSize.width != preferredFrameSize.width, @"Calculated height (%f) should be equal to preferred height (%f)", calculatedSize.width, preferredFrameSize.width);
+  
+  _editableTextNode.preferredFrameSize = CGSizeZero;
+}
+
 - (void)testCalculatedSizeIsGreaterThanOrEqualToConstrainedSize
 {
  for (NSInteger i = 10; i < 500; i += 50) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_editableTextNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_editableTextNode measure:constrainedSize];
    XCTAssertTrue(calculatedSize.width <= constrainedSize.width, @"Calculated width (%f) should be less than or equal to constrained width (%f)", calculatedSize.width, constrainedSize.width);
    XCTAssertTrue(calculatedSize.height <= constrainedSize.height, @"Calculated height (%f) should be less than or equal to constrained height (%f)", calculatedSize.height, constrainedSize.height);
  }
@@ -153,8 +164,8 @@ static BOOL CGSizeEqualToSizeWithIn(CGSize size1, CGSize size2, CGFloat delta)
 {
  for (NSInteger i = 10; i < 500; i += 50) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_editableTextNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
-    CGSize recalculatedSize = [_editableTextNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_editableTextNode measure:constrainedSize];
+    CGSize recalculatedSize = [_editableTextNode measure:calculatedSize];
    
    XCTAssertTrue(CGSizeEqualToSizeWithIn(calculatedSize, recalculatedSize, 4.0), @"Recalculated size %@ should be same as original size %@", NSStringFromCGSize(recalculatedSize), NSStringFromCGSize(calculatedSize));
  }
@@ -164,8 +175,8 @@ static BOOL CGSizeEqualToSizeWithIn(CGSize size1, CGSize size2, CGFloat delta)
 {
  for (CGFloat i = 10; i < 500; i *= 1.3) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_editableTextNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
-    CGSize recalculatedSize = [_editableTextNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_editableTextNode measure:constrainedSize];
+    CGSize recalculatedSize = [_editableTextNode measure:calculatedSize];

    XCTAssertTrue(CGSizeEqualToSizeWithIn(calculatedSize, recalculatedSize, 11.0), @"Recalculated size %@ should be same as original size %@", NSStringFromCGSize(recalculatedSize), NSStringFromCGSize(calculatedSize));
  }
--- a/AsyncDisplayKitTests/ASImageNodeSnapshotTests.m
+++ b/AsyncDisplayKitTests/ASImageNodeSnapshotTests.m
@@ -20,8 +20,7 @@
 - (UIImage *)testImage
 {
  NSString *path = [[NSBundle bundleForClass:[self class]] pathForResource:@"logo-square"
-                                                                    ofType:@"png"
-                                                               inDirectory:@"TestResources"];
+                                                                    ofType:@"png" inDirectory:@"TestResources"];
  return [UIImage imageWithContentsOfFile:path];
 }

@@ -30,32 +29,30 @@
  // trivial test case to ensure ASSnapshotTestCase works
  ASImageNode *imageNode = [[ASImageNode alloc] init];
  imageNode.image = [self testImage];
-  [imageNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))];
+  [imageNode measure:CGSizeMake(100, 100)];

  ASSnapshotVerifyNode(imageNode, nil);
 }

 - (void)testForcedScaling
 {
-  CGSize forcedImageSize = CGSizeMake(100, 100);
-  
  ASImageNode *imageNode = [[ASImageNode alloc] init];
-  imageNode.forcedSize = forcedImageSize;
+  
  imageNode.image = [self testImage];
+  imageNode.forcedSize = CGSizeMake(100, 100);
  
  // Snapshot testing requires that node is formally laid out.
-  [imageNode setSizeWithCGSize:forcedImageSize];
-  [imageNode layoutThatFits:ASSizeRangeMake(CGSizeZero, forcedImageSize)];
+  imageNode.preferredFrameSize = CGSizeMake(100, 100);
+  [imageNode measure:CGSizeMake(100, 100)];
+
  ASSnapshotVerifyNode(imageNode, @"first");
  
-  [imageNode setSizeWithCGSize:CGSizeMake(200, 200)];
-  [imageNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(200, 200))];
+  imageNode.preferredFrameSize = CGSizeMake(200, 200);
+  [imageNode measure:CGSizeMake(200, 200)];
  
  ASSnapshotVerifyNode(imageNode, @"second");
  
-  XCTAssert(CGImageGetWidth((CGImageRef)imageNode.contents) == forcedImageSize.width * imageNode.contentsScale &&
-            CGImageGetHeight((CGImageRef)imageNode.contents) == forcedImageSize.height * imageNode.contentsScale,
-            @"Contents should be 100 x 100 by contents scale.");
+  XCTAssert(CGImageGetWidth((CGImageRef)imageNode.contents) == 100 * imageNode.contentsScale && CGImageGetHeight((CGImageRef)imageNode.contents) == 100 * imageNode.contentsScale, @"contents should be 100 x 100 by contents scale.");
 }

@end
--- a/AsyncDisplayKitTests/ASInsetLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASInsetLayoutSpecSnapshotTests.mm
@@ -50,14 +50,12 @@ static NSString *nameForInsets(UIEdgeInsets insets)
  for (NSUInteger combination = 0; combination < 16; combination++) {
    UIEdgeInsets insets = insetsForCombination(combination, 10);
    ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor grayColor]);
-    ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], {10, 10});
+    ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+    foregroundNode.staticSize = {10, 10};
    
    ASLayoutSpec *layoutSpec =
    [ASBackgroundLayoutSpec
-     backgroundLayoutSpecWithChild:
-     [ASInsetLayoutSpec
-      insetLayoutSpecWithInsets:insets
-      child:foregroundNode]
+     backgroundLayoutSpecWithChild:[ASInsetLayoutSpec insetLayoutSpecWithInsets:insets child:foregroundNode]
     background:backgroundNode];
    
    static ASSizeRange kVariableSize = {{0, 0}, {300, 300}};
@@ -73,14 +71,12 @@ static NSString *nameForInsets(UIEdgeInsets insets)
  for (NSUInteger combination = 0; combination < 16; combination++) {
    UIEdgeInsets insets = insetsForCombination(combination, 10);
    ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor grayColor]);
-    ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], {10, 10});
+    ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+    foregroundNode.staticSize = {10, 10};
    
    ASLayoutSpec *layoutSpec =
    [ASBackgroundLayoutSpec
-     backgroundLayoutSpecWithChild:
-     [ASInsetLayoutSpec
-      insetLayoutSpecWithInsets:insets
-      child:foregroundNode]
+     backgroundLayoutSpecWithChild:[ASInsetLayoutSpec insetLayoutSpecWithInsets:insets child:foregroundNode]
     background:backgroundNode];

    static ASSizeRange kFixedSize = {{300, 300}, {300, 300}};
@@ -97,14 +93,12 @@ static NSString *nameForInsets(UIEdgeInsets insets)
  for (NSUInteger combination = 0; combination < 16; combination++) {
    UIEdgeInsets insets = insetsForCombination(combination, 0);
    ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor grayColor]);
-    ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], {10, 10});
+    ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+    foregroundNode.staticSize = {10, 10};

    ASLayoutSpec *layoutSpec =
    [ASBackgroundLayoutSpec
-     backgroundLayoutSpecWithChild:
-     [ASInsetLayoutSpec
-      insetLayoutSpecWithInsets:insets
-      child:foregroundNode]
+     backgroundLayoutSpecWithChild:[ASInsetLayoutSpec insetLayoutSpecWithInsets:insets child:foregroundNode]
     background:backgroundNode];

    static ASSizeRange kFixedSize = {{300, 300}, {300, 300}};
--- a/AsyncDisplayKitTests/ASLayoutSpecSnapshotTestsHelper.h
+++ b/AsyncDisplayKitTests/ASLayoutSpecSnapshotTestsHelper.h
@@ -31,16 +31,17 @@
            identifier:(NSString *)identifier;
@end

-__attribute__((overloadable)) static inline ASDisplayNode *ASDisplayNodeWithBackgroundColor(UIColor *backgroundColor, CGSize size) {
-  ASDisplayNode *node = [[ASDisplayNode alloc] init];
+@interface ASStaticSizeDisplayNode : ASDisplayNode
+
+@property (nonatomic) CGSize staticSize;
+
+@end
+
+static inline ASStaticSizeDisplayNode *ASDisplayNodeWithBackgroundColor(UIColor *backgroundColor)
+{
+  ASStaticSizeDisplayNode *node = [[ASStaticSizeDisplayNode alloc] init];
  node.layerBacked = YES;
  node.backgroundColor = backgroundColor;
-  node.width = ASDimensionMakeWithPoints(size.width);
-  node.height = ASDimensionMakeWithPoints(size.height);
+  node.staticSize = CGSizeZero;
  return node;
 }
-
-__attribute__((overloadable)) static inline ASDisplayNode *ASDisplayNodeWithBackgroundColor(UIColor *backgroundColor)
-{
-  return ASDisplayNodeWithBackgroundColor(backgroundColor, CGSizeZero);
-}
--- a/AsyncDisplayKitTests/ASLayoutSpecSnapshotTestsHelper.m
+++ b/AsyncDisplayKitTests/ASLayoutSpecSnapshotTestsHelper.m
@@ -39,7 +39,7 @@
  
  node.layoutSpecUnderTest = layoutSpec;
  
-  [node layoutThatFits:sizeRange];
+  [node measureWithSizeRange:sizeRange];
  ASSnapshotVerifyNode(node, identifier);
 }

@@ -60,3 +60,12 @@
 }

@end
+
+@implementation ASStaticSizeDisplayNode
+
+- (CGSize)calculateSizeThatFits:(CGSize)constrainedSize
+{
+  return _staticSize;
+}
+
+@end
--- a/AsyncDisplayKitTests/ASOverlayLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASOverlayLayoutSpecSnapshotTests.mm
@@ -23,7 +23,8 @@ static const ASSizeRange kSize = {{320, 320}, {320, 320}};
 - (void)testOverlay
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor blackColor], {20, 20});
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor blackColor]);
+  foregroundNode.staticSize = {20, 20};
  
  ASLayoutSpec *layoutSpec =
  [ASOverlayLayoutSpec
--- a/AsyncDisplayKitTests/ASRatioLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASRatioLayoutSpecSnapshotTests.mm
@@ -21,7 +21,8 @@ static const ASSizeRange kFixedSize = {{0, 0}, {100, 100}};

 - (void)testRatioLayoutSpecWithRatio:(CGFloat)ratio childSize:(CGSize)childSize identifier:(NSString *)identifier
 {
-  ASDisplayNode *subnode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], childSize);
+  ASStaticSizeDisplayNode *subnode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+  subnode.staticSize = childSize;
  
  ASLayoutSpec *layoutSpec = [ASRatioLayoutSpec ratioLayoutSpecWithRatio:ratio child:subnode];
  
--- a/AsyncDisplayKitTests/ASRelativeLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASRelativeLayoutSpecSnapshotTests.mm
@@ -23,6 +23,7 @@ static const ASSizeRange kSize = {{100, 120}, {320, 160}};

 - (void)testWithOptions
 {
+
  [self testAllVerticalPositionsForHorizontalPosition:ASRelativeLayoutSpecPositionStart];
  [self testAllVerticalPositionsForHorizontalPosition:ASRelativeLayoutSpecPositionCenter];
  [self testAllVerticalPositionsForHorizontalPosition:ASRelativeLayoutSpecPositionEnd];
@@ -56,16 +57,14 @@ static const ASSizeRange kSize = {{100, 120}, {320, 160}};
                   sizingOptions:(ASRelativeLayoutSpecSizingOption)sizingOptions
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor], CGSizeMake(70, 100));
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor greenColor]);
+  foregroundNode.staticSize = {70, 100};

  ASLayoutSpec *layoutSpec =
  [ASBackgroundLayoutSpec
   backgroundLayoutSpecWithChild:
   [ASRelativeLayoutSpec
-    relativePositionLayoutSpecWithHorizontalPosition:horizontalPosition
-    verticalPosition:verticalPosition
-    sizingOption:sizingOptions
-    child:foregroundNode]
+    relativePositionLayoutSpecWithHorizontalPosition:horizontalPosition verticalPosition:verticalPosition sizingOption:sizingOptions child:foregroundNode]
   background:backgroundNode];

  [self testLayoutSpec:layoutSpec
@@ -106,26 +105,17 @@ static NSString *suffixForPositionOptions(ASRelativeLayoutSpecPosition horizonta
 - (void)testMinimumSizeRangeIsGivenToChildWhenNotPositioning
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
-  ASDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor], CGSizeMake(10, 10));
+  ASStaticSizeDisplayNode *foregroundNode = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  foregroundNode.staticSize = {10, 10};
  foregroundNode.flexGrow = YES;
  
-  ASLayoutSpec *childSpec =
-  [ASBackgroundLayoutSpec
-   backgroundLayoutSpecWithChild:
-   [ASStackLayoutSpec
-    stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical
-    spacing:0
-    justifyContent:ASStackLayoutJustifyContentStart
-    alignItems:ASStackLayoutAlignItemsStart
-    children:@[foregroundNode]]
-   background:backgroundNode];
+  ASLayoutSpec *childSpec = [ASBackgroundLayoutSpec
+                             backgroundLayoutSpecWithChild:[ASStackLayoutSpec stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical spacing:0 justifyContent:ASStackLayoutJustifyContentStart alignItems:ASStackLayoutAlignItemsStart children:@[foregroundNode]]
+                             background:backgroundNode];
  
-  ASRelativeLayoutSpec *layoutSpec =
-  [ASRelativeLayoutSpec
-   relativePositionLayoutSpecWithHorizontalPosition:ASRelativeLayoutSpecPositionStart
-   verticalPosition:ASRelativeLayoutSpecPositionStart
-   sizingOption:{}
-   child:childSpec];
+  ASRelativeLayoutSpec *layoutSpec =  [ASRelativeLayoutSpec
+                                       relativePositionLayoutSpecWithHorizontalPosition:ASRelativeLayoutSpecPositionStart verticalPosition:ASRelativeLayoutSpecPositionStart sizingOption:{} child:childSpec];
+

  [self testLayoutSpec:layoutSpec sizeRange:kSize subnodes:@[backgroundNode, foregroundNode] identifier:nil];
 }
--- a/AsyncDisplayKitTests/ASStackLayoutSpecSnapshotTests.mm
+++ b/AsyncDisplayKitTests/ASStackLayoutSpecSnapshotTests.mm
@@ -23,31 +23,26 @@

 #pragma mark - Utility methods

-static NSArray<ASDisplayNode *> *defaultSubnodes()
+static NSArray *defaultSubnodes()
 {
  return defaultSubnodesWithSameSize(CGSizeZero, NO);
 }

-static NSArray<ASDisplayNode *> *defaultSubnodesWithSameSize(CGSize subnodeSize, BOOL flex)
+static NSArray *defaultSubnodesWithSameSize(CGSize subnodeSize, BOOL flex)
 {
-  NSArray<ASDisplayNode *> *subnodes = @[
-    ASDisplayNodeWithBackgroundColor([UIColor redColor], subnodeSize),
-    ASDisplayNodeWithBackgroundColor([UIColor blueColor], subnodeSize),
-    ASDisplayNodeWithBackgroundColor([UIColor greenColor], subnodeSize)
-  ];
-  for (ASDisplayNode *subnode in subnodes) {
+  NSArray *subnodes = @[
+                        ASDisplayNodeWithBackgroundColor([UIColor redColor]),
+                        ASDisplayNodeWithBackgroundColor([UIColor blueColor]),
+                        ASDisplayNodeWithBackgroundColor([UIColor greenColor])
+                        ];
+  for (ASStaticSizeDisplayNode *subnode in subnodes) {
+    subnode.staticSize = subnodeSize;
    subnode.flexGrow = flex;
    subnode.flexShrink = flex;
  }
  return subnodes;
 }

-static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
-{
-  node.width = ASDimensionMakeWithPoints(size.width);
-  node.height = ASDimensionMakeWithPoints(size.height);
-}
-
 - (void)testStackLayoutSpecWithJustify:(ASStackLayoutJustifyContent)justify
                                  flex:(BOOL)flex
                             sizeRange:(ASSizeRange)sizeRange
@@ -58,7 +53,7 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .justifyContent = justify
  };
  
-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, flex);
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, flex);
  
  [self testStackLayoutSpecWithStyle:style sizeRange:sizeRange subnodes:subnodes identifier:identifier];
 }
@@ -68,13 +63,13 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
                  itemsVerticalAlignment:(ASVerticalAlignment)verticalAlignment
                              identifier:(NSString *)identifier
 {
-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
  
  ASStackLayoutSpec *stackLayoutSpec = [[ASStackLayoutSpec alloc] init];
  stackLayoutSpec.direction = direction;
  stackLayoutSpec.children = subnodes;
-  stackLayoutSpec.horizontalAlignment = horizontalAlignment;
-  stackLayoutSpec.verticalAlignment = verticalAlignment;
+  [stackLayoutSpec setHorizontalAlignment:horizontalAlignment];
+  [stackLayoutSpec setVerticalAlignment:verticalAlignment];
  
  CGSize exactSize = CGSizeMake(200, 200);
  static ASSizeRange kSize = ASSizeRangeMake(exactSize, exactSize);
@@ -95,14 +90,11 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
                            subnodes:(NSArray *)subnodes
                          identifier:(NSString *)identifier
 {
-  ASStackLayoutSpec *stackLayoutSpec =
-  [ASStackLayoutSpec
-   stackLayoutSpecWithDirection:style.direction
-   spacing:style.spacing
-   justifyContent:style.justifyContent
-   alignItems:style.alignItems
-   children:children];
-
+  ASStackLayoutSpec *stackLayoutSpec = [ASStackLayoutSpec stackLayoutSpecWithDirection:style.direction
+                                                                               spacing:style.spacing
+                                                                        justifyContent:style.justifyContent
+                                                                            alignItems:style.alignItems
+                                                                              children:children];
  [self testStackLayoutSpec:stackLayoutSpec sizeRange:sizeRange subnodes:subnodes identifier:identifier];
 }

@@ -112,6 +104,7 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
                 identifier:(NSString *)identifier
 {
  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor whiteColor]);
+  
  ASLayoutSpec *layoutSpec = [ASBackgroundLayoutSpec backgroundLayoutSpecWithChild:stackLayoutSpec background:backgroundNode];
  
  NSMutableArray *newSubnodes = [NSMutableArray arrayWithObject:backgroundNode];
@@ -152,8 +145,8 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
-  subnodes[1].flexShrink = YES;
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
+  ((ASDisplayNode *)subnodes[1]).flexShrink = YES;
  
  // Width is 75px--that's less than the sum of the widths of the children, which is 100px.
  static ASSizeRange kSize = {{75, 0}, {75, 150}};
@@ -164,8 +157,8 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, YES);
-  setCGSizeToNode({150, 150}, subnodes[1]);
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, YES);
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {150, 150};

  // width 300px; height 0-150px.
  static ASSizeRange kUnderflowSize = {{300, 0}, {300, 150}};
@@ -180,10 +173,10 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionVertical};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 50}, subnodes[1]);
-  setCGSizeToNode({150, 50}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 50};
  
  // width 0-300px; height 300px
  static ASSizeRange kVariableHeight = {{0, 300}, {300, 300}};
@@ -201,10 +194,10 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .spacing = 10
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 50}, subnodes[1]);
-  setCGSizeToNode({150, 50}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 50};

  // width 0-300px; height 300px
  static ASSizeRange kVariableHeight = {{0, 300}, {300, 300}};
@@ -219,16 +212,12 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)

  ASLayoutSpec *layoutSpec =
  [ASInsetLayoutSpec
-   insetLayoutSpecWithInsets:{10, 10, 10, 10}
+   insetLayoutSpecWithInsets:{10, 10, 10 ,10}
   child:
   [ASBackgroundLayoutSpec
    backgroundLayoutSpecWithChild:
    [ASStackLayoutSpec
-     stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical
-     spacing:10
-     justifyContent:ASStackLayoutJustifyContentStart
-     alignItems:ASStackLayoutAlignItemsStretch
-     children:@[]]
+     stackLayoutSpecWithDirection:ASStackLayoutDirectionVertical spacing:10 justifyContent:ASStackLayoutJustifyContentStart alignItems:ASStackLayoutAlignItemsStretch children:@[]]
    background:backgroundNode]];
  
  // width 300px; height 0-300px
@@ -242,28 +231,28 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
  static ASSizeRange kAnySize = {{0, 0}, {INFINITY, INFINITY}};
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionVertical};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};
  
-  subnodes[1].spacingBefore = 10;
-  subnodes[2].spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 10;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 20;
  [self testStackLayoutSpecWithStyle:style sizeRange:kAnySize subnodes:subnodes identifier:@"spacingBefore"];
  // Reset above spacing values
-  subnodes[1].spacingBefore = 0;
-  subnodes[2].spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 0;

-  subnodes[1].spacingAfter = 10;
-  subnodes[2].spacingAfter = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingAfter = 10;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingAfter = 20;
  [self testStackLayoutSpecWithStyle:style sizeRange:kAnySize subnodes:subnodes identifier:@"spacingAfter"];
  // Reset above spacing values
-  subnodes[1].spacingAfter = 0;
-  subnodes[2].spacingAfter = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingAfter = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingAfter = 0;
  
  style.spacing = 10;
-  subnodes[1].spacingBefore = -10;
-  subnodes[1].spacingAfter = -10;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = -10;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingAfter = -10;
  [self testStackLayoutSpecWithStyle:style sizeRange:kAnySize subnodes:subnodes identifier:@"spacingBalancedOut"];
 }

@@ -274,14 +263,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .justifyContent = ASStackLayoutJustifyContentCenter
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};

-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  // width 0-300px; height 300px
  static ASSizeRange kVariableHeight = {{0, 300}, {300, 300}};
@@ -295,7 +284,8 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .justifyContent = ASStackLayoutJustifyContentSpaceBetween
  };

-  ASDisplayNode *child = ASDisplayNodeWithBackgroundColor([UIColor redColor], {50, 50});
+  ASStaticSizeDisplayNode *child = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  child.staticSize = {50, 50};
  
  // width 300px; height 0-INF
  static ASSizeRange kVariableHeight = {{300, 0}, {300, INFINITY}};
@@ -309,7 +299,8 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .justifyContent = ASStackLayoutJustifyContentSpaceAround
  };
  
-  ASDisplayNode *child = ASDisplayNodeWithBackgroundColor([UIColor redColor], {50, 50});
+  ASStaticSizeDisplayNode *child = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  child.staticSize = {50, 50};
  
  // width 300px; height 0-INF
  static ASSizeRange kVariableHeight = {{300, 0}, {300, INFINITY}};
@@ -334,11 +325,12 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  ASDisplayNode * subnode1 = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
-  ASDisplayNode * subnode2 = ASDisplayNodeWithBackgroundColor([UIColor redColor], {50, 50});
+  ASStaticSizeDisplayNode * subnode1 = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
+  ASStaticSizeDisplayNode * subnode2 = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  subnode2.staticSize = {50, 50};
  
  ASRatioLayoutSpec *child1 = [ASRatioLayoutSpec ratioLayoutSpecWithRatio:1.5 child:subnode1];
-  child1.flexBasis = ASDimensionMakeWithFraction(1);
+  child1.flexBasis = ASRelativeDimensionMakeWithFraction(1);
  child1.flexGrow = YES;
  child1.flexShrink = YES;
  
@@ -353,13 +345,15 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsCenter
  };

-  ASDisplayNode *subnode1 = ASDisplayNodeWithBackgroundColor([UIColor redColor], {100, 100});
+  ASStaticSizeDisplayNode *subnode1 = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  subnode1.staticSize = {100, 100};
  subnode1.flexShrink = YES;

-  ASDisplayNode *subnode2 = ASDisplayNodeWithBackgroundColor([UIColor blueColor], {50, 50});
+  ASStaticSizeDisplayNode *subnode2 = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
+  subnode2.staticSize = {50, 50};
  subnode2.flexShrink = YES;

-  NSArray<ASDisplayNode *> *subnodes = @[subnode1, subnode2];
+  NSArray *subnodes = @[subnode1, subnode2];
  static ASSizeRange kFixedWidth = {{150, 0}, {150, 100}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kFixedWidth subnodes:subnodes identifier:nil];
 }
@@ -368,12 +362,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  ASDisplayNode *subnode1 = ASDisplayNodeWithBackgroundColor([UIColor redColor], {100, 100});
+  ASStaticSizeDisplayNode *subnode1 = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  subnode1.staticSize = {100, 100};
  
-  ASDisplayNode *subnode2 = ASDisplayNodeWithBackgroundColor([UIColor blueColor], {50, 50});
+  ASStaticSizeDisplayNode *subnode2 = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
+  subnode2.staticSize = {50, 50};
  subnode2.alignSelf = ASStackLayoutAlignSelfCenter;

-  NSArray<ASDisplayNode *> *subnodes = @[subnode1, subnode2];
+  NSArray *subnodes = @[subnode1, subnode2];
  static ASSizeRange kFixedWidth = {{150, 0}, {150, INFINITY}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kFixedWidth subnodes:subnodes identifier:nil];
 }
@@ -386,14 +382,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsStart
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};
  
-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  static ASSizeRange kExactSize = {{300, 300}, {300, 300}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kExactSize subnodes:subnodes identifier:nil];
@@ -407,14 +403,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsEnd
  };
  
-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};
  
-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  static ASSizeRange kExactSize = {{300, 300}, {300, 300}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kExactSize subnodes:subnodes identifier:nil];
@@ -428,14 +424,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsCenter
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};
  
-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  static ASSizeRange kExactSize = {{300, 300}, {300, 300}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kExactSize subnodes:subnodes identifier:nil];
@@ -449,14 +445,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsStretch
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};

-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  static ASSizeRange kVariableSize = {{200, 200}, {300, 300}};
  // all children should be 200px wide
@@ -471,14 +467,14 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
    .alignItems = ASStackLayoutAlignItemsStretch
  };

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({100, 70}, subnodes[1]);
-  setCGSizeToNode({150, 90}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 70};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {150, 90};
  
-  subnodes[0].spacingBefore = 0;
-  subnodes[1].spacingBefore = 20;
-  subnodes[2].spacingBefore = 30;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).spacingBefore = 0;
+  ((ASStaticSizeDisplayNode *)subnodes[1]).spacingBefore = 20;
+  ((ASStaticSizeDisplayNode *)subnodes[2]).spacingBefore = 30;

  static ASSizeRange kVariableSize = {{50, 50}, {300, 300}};
  // all children should be 150px wide
@@ -495,12 +491,12 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
-  setCGSizeToNode({150, 150}, subnodes[1]);
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {150, 150};

-  for (ASDisplayNode *subnode in subnodes) {
+  for (ASStaticSizeDisplayNode *subnode in subnodes) {
    subnode.flexGrow = YES;
-    subnode.flexBasis = ASDimensionMakeWithPoints(10);
+    subnode.flexBasis = ASRelativeDimensionMakeWithPoints(10);
  }

  // width 300px; height 0-150px.
@@ -516,14 +512,15 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
-  for (ASDisplayNode *subnode in subnodes) {
+  NSArray *subnodes = defaultSubnodesWithSameSize({50, 50}, NO);
+  
+  for (ASStaticSizeDisplayNode *subnode in subnodes) {
    subnode.flexGrow = YES;
  }

  // This should override the intrinsic size of 50pts and instead compute to 50% = 100pts.
  // The result should be that the red box is twice as wide as the blue and gree boxes after flexing.
-  subnodes[0].flexBasis = ASDimensionMakeWithFraction(0.5);
+  ((ASStaticSizeDisplayNode *)subnodes[0]).flexBasis = ASRelativeDimensionMakeWithFraction(0.5);

  static ASSizeRange kSize = {{200, 0}, {200, INFINITY}};
  [self testStackLayoutSpecWithStyle:style sizeRange:kSize subnodes:subnodes identifier:nil];
@@ -533,13 +530,13 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};

-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();
-  setCGSizeToNode({50, 50}, subnodes[0]);
-  setCGSizeToNode({150, 150}, subnodes[1]);
-  setCGSizeToNode({150, 50}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {50, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {150, 150};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {50, 50};

-  for (ASDisplayNode *subnode in subnodes) {
-    subnode.flexBasis = ASDimensionMakeWithPoints(20);
+  for (ASStaticSizeDisplayNode *subnode in subnodes) {
+    subnode.flexBasis = ASRelativeDimensionMakeWithPoints(20);
  }
  
  static ASSizeRange kSize = {{300, 0}, {300, 150}};
@@ -548,11 +545,13 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)

 - (void)testCrossAxisStretchingOccursAfterStackAxisFlexing
 {
-  NSArray<ASDisplayNode *> *subnodes = @[
-    ASDisplayNodeWithBackgroundColor([UIColor greenColor]),
-    ASDisplayNodeWithBackgroundColor([UIColor blueColor], {10, 0}),
-    ASDisplayNodeWithBackgroundColor([UIColor redColor], {3000, 3000})
-  ];
+  NSArray *subnodes = @[
+                        ASDisplayNodeWithBackgroundColor([UIColor greenColor]),
+                        ASDisplayNodeWithBackgroundColor([UIColor blueColor]),
+                        ASDisplayNodeWithBackgroundColor([UIColor redColor])
+                        ];
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {10, 0};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {3000, 3000};
  
  ASRatioLayoutSpec *child2 = [ASRatioLayoutSpec ratioLayoutSpecWithRatio:1.0 child:subnodes[2]];
  child2.flexGrow = YES;
@@ -566,12 +565,7 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
   [ASInsetLayoutSpec
    insetLayoutSpecWithInsets:UIEdgeInsetsMake(10, 10, 10, 10)
    child:
-    [ASStackLayoutSpec
-     stackLayoutSpecWithDirection:ASStackLayoutDirectionHorizontal
-     spacing:0
-     justifyContent:ASStackLayoutJustifyContentStart
-     alignItems:ASStackLayoutAlignItemsStretch
-     children:@[subnodes[1], child2]]
+    [ASStackLayoutSpec stackLayoutSpecWithDirection:ASStackLayoutDirectionHorizontal spacing:0 justifyContent:ASStackLayoutJustifyContentStart alignItems:ASStackLayoutAlignItemsStretch children:@[subnodes[1], child2,]]
    ]
   background:subnodes[0]];

@@ -582,16 +576,17 @@ static void setCGSizeToNode(CGSize size, ASDisplayNode *node)
 - (void)testViolationIsDistributedEquallyAmongFlexibleChildren
 {
  ASStackLayoutSpecStyle style = {.direction = ASStackLayoutDirectionHorizontal};
-  
-  NSArray<ASDisplayNode *> *subnodes = defaultSubnodes();

-  setCGSizeToNode({300, 50}, subnodes[0]);
-  setCGSizeToNode({100, 50}, subnodes[1]);
-  setCGSizeToNode({200, 50}, subnodes[2]);
+  NSArray *subnodes = defaultSubnodes();
  
-  subnodes[0].flexShrink = YES;
-  subnodes[1].flexShrink = NO;
-  subnodes[2].flexShrink = YES;
+  ((ASStaticSizeDisplayNode *)subnodes[0]).staticSize = {300, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[0]).flexShrink = YES;
+  
+  ((ASStaticSizeDisplayNode *)subnodes[1]).staticSize = {100, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[1]).flexShrink = NO;
+  
+  ((ASStaticSizeDisplayNode *)subnodes[2]).staticSize = {200, 50};
+  ((ASStaticSizeDisplayNode *)subnodes[2]).flexShrink = YES;
  
  // A width of 400px results in a violation of 200px. This is distributed equally among each flexible child,
  // causing both of them to be shrunk by 100px, resulting in widths of 300px, 100px, and 50px.
--- a/AsyncDisplayKitTests/ASStaticLayoutSpecSnapshotTests.m
+++ b/AsyncDisplayKitTests/ASStaticLayoutSpecSnapshotTests.m
@@ -22,34 +22,46 @@

 - (void)testSizingBehaviour
 {
-  [self testWithSizeRange:ASSizeRangeMake(CGSizeMake(150, 200), CGSizeMake(INFINITY, INFINITY))
+  [self testWithSizeRange:ASSizeRangeMake(CGSizeMake(150, 200), CGSizeMake(FLT_MAX, FLT_MAX))
               identifier:@"underflowChildren"];
  [self testWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(50, 100))
               identifier:@"overflowChildren"];
  // Expect the spec to wrap its content because children sizes are between constrained size
-  [self testWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(INFINITY / 2, INFINITY / 2))
+  [self testWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(FLT_MAX / 2, FLT_MAX / 2))
               identifier:@"wrappedChildren"];
 }

 - (void)testChildrenMeasuredWithAutoMaxSize
 {
-  ASDisplayNode *firstChild = ASDisplayNodeWithBackgroundColor([UIColor redColor], (CGSize){50, 50});
+  ASStaticSizeDisplayNode *firstChild = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
  firstChild.layoutPosition = CGPointMake(0, 0);
+  firstChild.staticSize = CGSizeMake(50, 50);
  
-  ASDisplayNode *secondChild = ASDisplayNodeWithBackgroundColor([UIColor blueColor], (CGSize){100, 100});
+  ASStaticSizeDisplayNode *secondChild = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
  secondChild.layoutPosition = CGPointMake(10, 60);
+  secondChild.staticSize = CGSizeMake(100, 100);

  ASSizeRange sizeRange = ASSizeRangeMake(CGSizeMake(10, 10), CGSizeMake(110, 160));
  [self testWithChildren:@[firstChild, secondChild] sizeRange:sizeRange identifier:nil];
+  
+  XCTAssertTrue(ASSizeRangeEqualToSizeRange(firstChild.constrainedSizeForCalculatedLayout,
+                                            ASSizeRangeMake(CGSizeZero, sizeRange.max)));
+  CGSize secondChildMaxSize = CGSizeMake(sizeRange.max.width - secondChild.layoutPosition.x,
+                                         sizeRange.max.height - secondChild.layoutPosition.y);
+  XCTAssertTrue(ASSizeRangeEqualToSizeRange(secondChild.constrainedSizeForCalculatedLayout,
+                                            ASSizeRangeMake(CGSizeZero, secondChildMaxSize)));
 }

 - (void)testWithSizeRange:(ASSizeRange)sizeRange identifier:(NSString *)identifier
 {
-  ASDisplayNode *firstChild = ASDisplayNodeWithBackgroundColor([UIColor redColor], (CGSize){50, 50});
+  ASDisplayNode *firstChild = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
  firstChild.layoutPosition = CGPointMake(0, 0);
+  firstChild.sizeRange = ASRelativeSizeRangeMakeWithExactCGSize(CGSizeMake(50, 50));
  
-  ASDisplayNode *secondChild = ASDisplayNodeWithBackgroundColor([UIColor blueColor], (CGSize){100, 100});
+  
+  ASDisplayNode *secondChild = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
  secondChild.layoutPosition = CGPointMake(0, 50);
+  secondChild.sizeRange = ASRelativeSizeRangeMakeWithExactCGSize(CGSizeMake(100, 100));
  
  [self testWithChildren:@[firstChild, secondChild] sizeRange:sizeRange identifier:identifier];
 }
@@ -61,12 +73,9 @@
  NSMutableArray *subnodes = [NSMutableArray arrayWithArray:children];
  [subnodes insertObject:backgroundNode atIndex:0];

-  ASLayoutSpec *layoutSpec =
-  [ASBackgroundLayoutSpec
-   backgroundLayoutSpecWithChild:
-   [ASStaticLayoutSpec
-    staticLayoutSpecWithChildren:children]
-   background:backgroundNode];
+  ASStaticLayoutSpec *staticLayoutSpec = [ASStaticLayoutSpec staticLayoutSpecWithChildren:children];
+  ASLayoutSpec *layoutSpec = [ASBackgroundLayoutSpec backgroundLayoutSpecWithChild:staticLayoutSpec
+                                                                        background:backgroundNode];
  
  [self testLayoutSpec:layoutSpec sizeRange:sizeRange subnodes:subnodes identifier:identifier];
 }
--- a/AsyncDisplayKitTests/ASTableViewTests.m
+++ b/AsyncDisplayKitTests/ASTableViewTests.m
@@ -148,7 +148,7 @@

 - (ASSizeRange)tableView:(ASTableView *)tableView constrainedSizeForRowAtIndexPath:(NSIndexPath *)indexPath
 {
-  return ASSizeRangeMake(CGSizeMake(10, 42));
+  return ASSizeRangeMakeExactSize(CGSizeMake(10, 42));
 }

@end
--- a/AsyncDisplayKitTests/ASTextNodePerformanceTests.m
+++ b/AsyncDisplayKitTests/ASTextNodePerformanceTests.m
@@ -9,7 +9,6 @@
 #import <XCTest/XCTest.h>
 #import "ASPerformanceTestContext.h"
 #import <AsyncDisplayKit/ASTextNode.h>
-#import <AsyncDisplayKit/ASLayout.h>
 #import "ASinternalHelpers.h"
 #import "ASXCTExtensions.h"
 #include "CGRect+ASConvenience.h"
@@ -72,7 +71,7 @@ static NSString *const kTestCaseUIKitWithReusedContext = @"UIKitReusedContext";
    NSAttributedString *text = data[i % data.count];
    startMeasuring();
    node.attributedText = text;
-    asdkSize = [node layoutThatFits:ASSizeRangeMake(CGSizeZero, maxSize)].size;
+    asdkSize = [node measure:maxSize];
    stopMeasuring();
  }];
  ctx.results[kTestCaseASDK].userInfo[@"size"] = NSStringFromCGSize(asdkSize);
@@ -102,7 +101,7 @@ static NSString *const kTestCaseUIKitWithReusedContext = @"UIKitReusedContext";
    ASTextNode *node = [[ASTextNode alloc] init];
    startMeasuring();
    node.attributedText = text;
-    asdkSize = [node layoutThatFits:ASSizeRangeMake(CGSizeZero, maxSize)].size;
+    asdkSize = [node measure:maxSize];
    stopMeasuring();
  }];
  ctx.results[kTestCaseASDK].userInfo[@"size"] = NSStringFromCGSize(asdkSize);
@@ -132,7 +131,7 @@ static NSString *const kTestCaseUIKitWithReusedContext = @"UIKitReusedContext";
    ASTextNode *node = [[ASTextNode alloc] init];
    startMeasuring();
    node.attributedText = text;
-    asdkSize = [node layoutThatFits:ASSizeRangeMake(CGSizeZero, maxSize)].size;
+    asdkSize = [node measure:maxSize];
    stopMeasuring();
  }];
  testCtx.results[kTestCaseASDK].userInfo[@"size"] = NSStringFromCGSize(asdkSize);
--- a/AsyncDisplayKitTests/ASTextNodeSnapshotTests.m
+++ b/AsyncDisplayKitTests/ASTextNodeSnapshotTests.m
@@ -10,8 +10,8 @@
 //

 #import "ASSnapshotTestCase.h"
+
 #import <AsyncDisplayKit/AsyncDisplayKit.h>
-#import "ASLayout.h"

@interface ASTextNodeSnapshotTests : ASSnapshotTestCase

@@ -25,7 +25,7 @@
  ASTextNode *textNode = [[ASTextNode alloc] init];
  textNode.attributedText = [[NSAttributedString alloc] initWithString:@"judar"
                                                            attributes:@{NSFontAttributeName : [UIFont italicSystemFontOfSize:24]}];
-  [textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX))];
+  [textNode measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX))];
  textNode.textContainerInset = UIEdgeInsetsMake(0, 2, 0, 2);
  
  ASSnapshotVerifyNode(textNode, nil);
@@ -40,7 +40,7 @@
  textNode.attributedText = [[NSAttributedString alloc] initWithString:@"judar judar judar judar judar judar"
                                                            attributes:@{ NSFontAttributeName : [UIFont systemFontOfSize:30] }];
  
-  [textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 80))];
+  [textNode measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 80))];
  textNode.frame = CGRectMake(50, 50, textNode.calculatedSize.width, textNode.calculatedSize.height);
  textNode.textContainerInset = UIEdgeInsetsMake(10, 10, 10, 10);

@@ -62,7 +62,7 @@
  textNode.attributedText = [[NSAttributedString alloc] initWithString:@"yolo"
                                                            attributes:@{ NSFontAttributeName : [UIFont systemFontOfSize:30] }];

-  [textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX))];
+  [textNode measureWithSizeRange:ASSizeRangeMake(CGSizeZero, CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX))];
  textNode.frame = CGRectMake(50, 50, textNode.calculatedSize.width, textNode.calculatedSize.height);
  textNode.textContainerInset = UIEdgeInsetsMake(5, 10, 10, 5);

--- a/AsyncDisplayKitTests/ASTextNodeTests.m
+++ b/AsyncDisplayKitTests/ASTextNodeTests.m
@@ -12,7 +12,6 @@

 #import <OCMock/OCMock.h>

-#import <AsyncDisplayKit/ASLayout.h>
 #import <AsyncDisplayKit/ASTextNode.h>

 #import <XCTest/XCTest.h>
@@ -112,7 +111,7 @@
 {
  for (NSInteger i = 10; i < 500; i += 50) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_textNode measure:constrainedSize];
    XCTAssertTrue(calculatedSize.width <= constrainedSize.width, @"Calculated width (%f) should be less than or equal to constrained width (%f)", calculatedSize.width, constrainedSize.width);
    XCTAssertTrue(calculatedSize.height <= constrainedSize.height, @"Calculated height (%f) should be less than or equal to constrained height (%f)", calculatedSize.height, constrainedSize.height);
  }
@@ -122,8 +121,8 @@
 {
  for (NSInteger i = 10; i < 500; i += 50) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
-    CGSize recalculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_textNode measure:constrainedSize];
+    CGSize recalculatedSize = [_textNode measure:constrainedSize];
    
    XCTAssertTrue(CGSizeEqualToSizeWithIn(calculatedSize, recalculatedSize, 4.0), @"Recalculated size %@ should be same as original size %@", NSStringFromCGSize(recalculatedSize), NSStringFromCGSize(calculatedSize));
  }
@@ -133,8 +132,8 @@
 {
  for (CGFloat i = 10; i < 500; i *= 1.3) {
    CGSize constrainedSize = CGSizeMake(i, i);
-    CGSize calculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
-    CGSize recalculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+    CGSize calculatedSize = [_textNode measure:constrainedSize];
+    CGSize recalculatedSize = [_textNode measure:constrainedSize];

    XCTAssertTrue(CGSizeEqualToSizeWithIn(calculatedSize, recalculatedSize, 11.0), @"Recalculated size %@ should be same as original size %@", NSStringFromCGSize(recalculatedSize), NSStringFromCGSize(calculatedSize));
  }
@@ -144,9 +143,9 @@
 {
  _textNode.placeholderEnabled = YES;
  
-  XCTAssertNoThrow([_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeZero)], @"Measure with zero size and placeholder enabled should not throw an exception");
-  XCTAssertNoThrow([_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(0, 100))], @"Measure with zero width and placeholder enabled should not throw an exception");
-  XCTAssertNoThrow([_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 0))], @"Measure with zero height and placeholder enabled should not throw an exception");
+  XCTAssertNoThrow([_textNode measure:CGSizeZero], @"Measure with zero size and placeholder enabled should not throw an exception");
+  XCTAssertNoThrow([_textNode measure:CGSizeMake(0, 100)], @"Measure with zero width and placeholder enabled should not throw an exception");
+  XCTAssertNoThrow([_textNode measure:CGSizeMake(100, 0)], @"Measure with zero height and placeholder enabled should not throw an exception");
 }

 - (void)testAccessibility
@@ -171,7 +170,7 @@
  ASTextNodeTestDelegate *delegate = [ASTextNodeTestDelegate new];
  _textNode.delegate = delegate;

-  [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))];
+  [_textNode measure:CGSizeMake(100, 100)];
  NSRange returnedLinkRange;
  NSString *returnedAttributeName;
  NSString *returnedLinkAttributeValue = [_textNode linkAttributeValueAtPoint:CGPointMake(3, 3) attributeName:&returnedAttributeName range:&returnedLinkRange];
@@ -193,7 +192,7 @@
  ASTextNodeTestDelegate *delegate = [ASTextNodeTestDelegate new];
  _textNode.delegate = delegate;

-  CGSize calculatedSize = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, CGSizeMake(100, 100))].size;
+  CGSize calculatedSize = [_textNode measure:CGSizeMake(100, 100)];
  NSRange returnedLinkRange = NSMakeRange(NSNotFound, 0);
  NSRange expectedRange = NSMakeRange(NSNotFound, 0);
  NSString *returnedAttributeName;
@@ -219,9 +218,9 @@
 - (void)testAddingExclusionPathsShouldInvalidateAndIncreaseTheSize
 {
  CGSize constrainedSize = CGSizeMake(100, CGFLOAT_MAX);
-  CGSize sizeWithoutExclusionPaths = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+  CGSize sizeWithoutExclusionPaths = [_textNode measure:constrainedSize];
  _textNode.exclusionPaths = @[[UIBezierPath bezierPathWithRect:CGRectMake(50, 20, 30, 40)]];
-  CGSize sizeWithExclusionPaths = [_textNode layoutThatFits:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;
+  CGSize sizeWithExclusionPaths = [_textNode measure:constrainedSize];

  XCTAssertGreaterThan(sizeWithExclusionPaths.height, sizeWithoutExclusionPaths.height, @"Setting exclusions paths should invalidate the calculated size and return a greater size");
 }