Merge branch 'master' into update-objc

Conflicts:
	AsyncDisplayKit/ASCollectionView.h
	AsyncDisplayKit/ASDisplayNode.h
	AsyncDisplayKit/Details/ASDataController.h
	AsyncDisplayKit/Details/UIView+ASConvenience.h
	AsyncDisplayKit/Layout/ASLayoutSpec.h

AsyncDisplayKitTests/ASCollectionViewFlowLayoutInspectorTests.m

@@ -0,0 +1,368 @@
+/* Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <XCTest/XCTest.h>
+#import <UIKit/UIKit.h>
+
+#import "ASCollectionView.h"
+#import "ASCollectionViewFlowLayoutInspector.h"
+
+/**
+ * Test Data Source
+ */
+@interface InspectorTestDataSource : NSObject <ASCollectionViewDataSource>
+@end
+
+@implementation InspectorTestDataSource
+
+- (ASCellNode *)collectionView:(ASCollectionView *)collectionView nodeForItemAtIndexPath:(NSIndexPath *)indexPath
+{
+  return [[ASCellNode alloc] init];
+}
+
+- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section
+{
+  return 0;
+}
+
+- (NSInteger)numberOfSectionsInCollectionView:(UICollectionView *)collectionView
+{
+  return 2;
+}
+
+@end
+
+@interface ASCollectionViewFlowLayoutInspectorTests : XCTestCase
+
+@end
+
+/**
+ * Test Delegate for Header Reference Size Implementation
+ */
+@interface HeaderReferenceSizeTestDelegate : NSObject <ASCollectionViewDelegateFlowLayout>
+
+@end
+
+@implementation HeaderReferenceSizeTestDelegate
+
+- (CGSize)collectionView:(ASCollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout referenceSizeForHeaderInSection:(NSInteger)section
+{
+  return CGSizeMake(125.0, 125.0);
+}
+
+@end
+
+/**
+ * Test Delegate for Footer Reference Size Implementation
+ */
+@interface FooterReferenceSizeTestDelegate : NSObject <ASCollectionViewDelegateFlowLayout>
+
+@end
+
+@implementation FooterReferenceSizeTestDelegate
+
+- (CGSize)collectionView:(ASCollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout referenceSizeForFooterInSection:(NSInteger)section
+{
+  return CGSizeMake(125.0, 125.0);
+}
+
+@end
+
+@implementation ASCollectionViewFlowLayoutInspectorTests
+
+- (void)setUp {
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown {
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+#pragma mark - #collectionView:constrainedSizeForSupplementaryNodeOfKind:atIndexPath:
+
+// Vertical
+
+// Delegate implementation
+
+- (void)testThatItReturnsAVerticalConstrainedSizeFromTheHeaderDelegateImplementation
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionVertical;
+
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(collectionView.bounds.size.width, 125.0));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the values returned in the delegate implementation");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsAVerticalConstrainedSizeFromTheFooterDelegateImplementation
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  FooterReferenceSizeTestDelegate *delegate = [[FooterReferenceSizeTestDelegate alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionVertical;
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionFooter atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(collectionView.bounds.size.width, 125.0));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the values returned in the delegate implementation");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+// Size implementation
+
+- (void)testThatItReturnsAVerticalConstrainedSizeFromTheHeaderProperty
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionVertical;
+  layout.headerReferenceSize = CGSizeMake(125.0, 125.0);
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(collectionView.bounds.size.width, 125.0));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the size set on the layout");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsAVerticalConstrainedSizeFromTheFooterProperty
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionVertical;
+  layout.footerReferenceSize = CGSizeMake(125.0, 125.0);
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionFooter atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(collectionView.bounds.size.width, 125.0));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the size set on the layout");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+// Horizontal
+
+- (void)testThatItReturnsAHorizontalConstrainedSizeFromTheHeaderDelegateImplementation
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionHorizontal;
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(125.0, collectionView.bounds.size.height));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the values returned in the delegate implementation");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsAHorizontalConstrainedSizeFromTheFooterDelegateImplementation
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  FooterReferenceSizeTestDelegate *delegate = [[FooterReferenceSizeTestDelegate alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionHorizontal;
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionFooter atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(125.0, collectionView.bounds.size.height));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the values returned in the delegate implementation");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+// Size implementation
+
+- (void)testThatItReturnsAHorizontalConstrainedSizeFromTheHeaderProperty
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionHorizontal;
+  layout.headerReferenceSize = CGSizeMake(125.0, 125.0);
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(125.0, collectionView.bounds.size.width));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the size set on the layout");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsAHorizontalConstrainedSizeFromTheFooterProperty
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.scrollDirection = UICollectionViewScrollDirectionHorizontal;
+  layout.footerReferenceSize = CGSizeMake(125.0, 125.0);
+  
+  CGRect rect = CGRectMake(0, 0, 100.0, 100.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:rect collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionFooter atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeMake(125.0, collectionView.bounds.size.height));
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a size constrained by the size set on the layout");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsZeroSizeWhenNoReferenceSizeIsImplemented
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  ASSizeRange size = [inspector collectionView:collectionView constrainedSizeForSupplementaryNodeOfKind:UICollectionElementKindSectionFooter atIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
+  ASSizeRange sizeCompare = ASSizeRangeMake(CGSizeZero, CGSizeZero);
+  XCTAssert(CGSizeEqualToSize(size.min, sizeCompare.min) && CGSizeEqualToSize(size.max, sizeCompare.max), @"should have a zero size");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+#pragma mark - #collectionView:numberOfSectionsForSupplementaryNodeOfKind:
+
+- (void)testThatItRespondsWithTheDefaultNumberOfSections
+{
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  NSUInteger sections = [inspector collectionView:collectionView numberOfSectionsForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader];
+  XCTAssert(sections == 1, @"should return 1 by default");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItProvidesTheNumberOfSectionsInTheDataSource
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  NSUInteger sections = [inspector collectionView:collectionView numberOfSectionsForSupplementaryNodeOfKind:UICollectionElementKindSectionHeader];
+  XCTAssert(sections == 2, @"should return 2");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+#pragma mark - #collectionView:supplementaryNodesOfKind:inSection:
+
+- (void)testThatItReturnsOneWhenAValidSizeIsImplementedOnTheDelegate
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  NSUInteger count = [inspector collectionView:collectionView supplementaryNodesOfKind:UICollectionElementKindSectionHeader inSection:0];
+  XCTAssert(count == 1, @"should have a header supplementary view");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsOneWhenAValidSizeIsImplementedOnTheLayout
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  layout.footerReferenceSize = CGSizeMake(125.0, 125.0);
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  NSUInteger count = [inspector collectionView:collectionView supplementaryNodesOfKind:UICollectionElementKindSectionFooter inSection:0];
+  XCTAssert(count == 1, @"should have a footer supplementary view");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+- (void)testThatItReturnsNoneWhenNoReferenceSizeIsImplemented
+{
+  InspectorTestDataSource *dataSource = [[InspectorTestDataSource alloc] init];
+  HeaderReferenceSizeTestDelegate *delegate = [[HeaderReferenceSizeTestDelegate alloc] init];
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout asyncDataFetching:NO];
+  collectionView.asyncDataSource = dataSource;
+  collectionView.asyncDelegate = delegate;
+  ASCollectionViewFlowLayoutInspector *inspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:collectionView flowLayout:layout];
+  NSUInteger count = [inspector collectionView:collectionView supplementaryNodesOfKind:UICollectionElementKindSectionFooter inSection:0];
+  XCTAssert(count == 0, @"should not have a footer supplementary view");
+  
+  collectionView.asyncDataSource = nil;
+  collectionView.asyncDelegate = nil;
+}
+
+@end

AsyncDisplayKitTests/ASCollectionViewTests.m

@@ -6,7 +6,9 @@
 //
 
 #import <XCTest/XCTest.h>
-#import <AsyncDisplayKit/ASCollectionView.h>
+#import "ASCollectionView.h"
+#import "ASCollectionDataController.h"
+#import "ASCollectionViewFlowLayoutInspector.h"
 
 @interface ASCollectionViewTestDelegate : NSObject <ASCollectionViewDataSource, ASCollectionViewDelegate>
 
@@ -73,13 +75,43 @@
 
 @end
 
+@interface ASCollectionView (InternalTesting)
+
+- (NSArray *)supplementaryNodeKindsInDataController:(ASCollectionDataController *)dataController;
+
+@end
+
 @interface ASCollectionViewTests : XCTestCase
 
 @end
 
 @implementation ASCollectionViewTests
 
-- (void)DISABLED_testCollectionViewController {
+- (void)testThatItSetsALayoutInspectorForFlowLayouts
+{
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout];
+  XCTAssert(collectionView.layoutInspector != nil, @"should automatically set a layout delegate for flow layouts");
+  XCTAssert([collectionView.layoutInspector isKindOfClass:[ASCollectionViewFlowLayoutInspector class]], @"should have a flow layout inspector by default");
+}
+
+- (void)testThatItDoesNotSetALayoutInspectorForCustomLayouts
+{
+  UICollectionViewLayout *layout = [[UICollectionViewLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout];
+  XCTAssert(collectionView.layoutInspector == nil, @"should not set a layout delegate for custom layouts");
+}
+
+- (void)testThatRegisteringASupplementaryNodeStoresItForIntrospection
+{
+  UICollectionViewFlowLayout *layout = [[UICollectionViewFlowLayout alloc] init];
+  ASCollectionView *collectionView = [[ASCollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout];
+  [collectionView registerSupplementaryNodeOfKind:UICollectionElementKindSectionHeader];
+  XCTAssertEqualObjects([collectionView supplementaryNodeKindsInDataController:nil], @[UICollectionElementKindSectionHeader]);
+}
+
+- (void)DISABLED_testCollectionViewController
+{
   ASCollectionViewTestController *testController = [[ASCollectionViewTestController alloc] initWithNibName:nil bundle:nil];
 
   UIView *containerView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 100, 100)];

AsyncDisplayKitTests/ASDisplayNodeAppearanceTests.m

@@ -56,9 +56,15 @@ static dispatch_block_t modifyMethodByAddingPrologueBlockAndReturnCleanupBlock(C
 @interface ASDisplayNodeAppearanceTests : XCTestCase
 @end
 
+// Conveniences for making nodes named a certain way
 #define DeclareNodeNamed(n) ASDisplayNode *n = [[ASDisplayNode alloc] init]; n.name = @#n
-#define DeclareViewNamed(v) UIView *v = [[UIView alloc] init]; v.layer.asyncdisplaykit_name = @#v
-#define DeclareLayerNamed(l) CALayer *l = [[CALayer alloc] init]; l.asyncdisplaykit_name = @#l
+#define DeclareViewNamed(v) UIView *v = viewWithName(@#v)
+
+static UIView *viewWithName(NSString *name) {
+  ASDisplayNode *n = [[ASDisplayNode alloc] init];
+  n.name = name;
+  return n.view;
+}
 
 @implementation ASDisplayNodeAppearanceTests
 {

AsyncDisplayKitTests/ASDisplayNodeTests.m

@@ -17,21 +17,33 @@
 #import "UIView+ASConvenience.h"
 
 // Conveniences for making nodes named a certain way
-
 #define DeclareNodeNamed(n) ASDisplayNode *n = [[ASDisplayNode alloc] init]; n.name = @#n
-#define DeclareViewNamed(v) UIView *v = [[UIView alloc] init]; v.layer.asyncdisplaykit_name = @#v
-#define DeclareLayerNamed(l) CALayer *l = [[CALayer alloc] init]; l.asyncdisplaykit_name = @#l
+#define DeclareViewNamed(v) UIView *v = viewWithName(@#v)
+#define DeclareLayerNamed(l) CALayer *l = layerWithName(@#l)
+
+static UIView *viewWithName(NSString *name) {
+  ASDisplayNode *n = [[ASDisplayNode alloc] init];
+  n.name = name;
+  return n.view;
+}
+
+static CALayer *layerWithName(NSString *name) {
+  ASDisplayNode *n = [[ASDisplayNode alloc] init];
+  n.layerBacked = YES;
+  n.name = name;
+  return n.layer;
+}
 
 static NSString *orderStringFromSublayers(CALayer *l) {
-  return [[[l.sublayers valueForKey:@"asyncdisplaykit_name"] allObjects] componentsJoinedByString:@","];
+  return [[l.sublayers valueForKey:@"name"] componentsJoinedByString:@","];
 }
 
 static NSString *orderStringFromSubviews(UIView *v) {
-  return [[[v.subviews valueForKeyPath:@"layer.asyncdisplaykit_name"] allObjects] componentsJoinedByString:@","];
+  return [[v.subviews valueForKey:@"name"] componentsJoinedByString:@","];
 }
 
 static NSString *orderStringFromSubnodes(ASDisplayNode *n) {
-  return [[[n.subnodes valueForKey:@"name"] allObjects] componentsJoinedByString:@","];
+  return [[n.subnodes valueForKey:@"name"] componentsJoinedByString:@","];
 }
 
 // Asserts subnode, subview, sublayer order match what you provide here
@@ -1375,7 +1387,6 @@ static inline BOOL _CGPointEqualToPointWithEpsilon(CGPoint point1, CGPoint point
   DeclareNodeNamed(b);
   DeclareNodeNamed(c);
   DeclareViewNamed(d);
-  DeclareLayerNamed(e);
 
   [parent layer];
 

AsyncDisplayKitTests/ASStaticLayoutSpecSnapshotTests.m

@@ -0,0 +1,85 @@
+//
+//  ASStaticLayoutSpecSnapshotTests.m
+//  AsyncDisplayKit
+//
+//  Created by Huy Nguyen on 18/10/15.
+//  Copyright (c) 2015 Facebook. All rights reserved.
+//
+
+#import "ASLayoutSpecSnapshotTestsHelper.h"
+
+#import "ASStaticLayoutSpec.h"
+#import "ASBackgroundLayoutSpec.h"
+
+@interface ASStaticLayoutSpecSnapshotTests : ASLayoutSpecSnapshotTestCase
+@end
+
+@implementation ASStaticLayoutSpecSnapshotTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.recordMode = NO;
+}
+
+- (void)testSizingBehaviour
+{
+  [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(FLT_MAX / 2, FLT_MAX / 2))
+               identifier:@"wrappedChildren"];
+}
+
+- (void)testChildrenMeasuredWithAutoMaxSize
+{
+  ASStaticSizeDisplayNode *firstChild = ASDisplayNodeWithBackgroundColor([UIColor redColor]);
+  firstChild.layoutPosition = CGPointMake(0, 0);
+  firstChild.staticSize = CGSizeMake(50, 50);
+  
+  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]);
+  firstChild.layoutPosition = CGPointMake(0, 0);
+  firstChild.sizeRange = ASRelativeSizeRangeMakeWithExactCGSize(CGSizeMake(50, 50));
+  
+  
+  ASDisplayNode *secondChild = ASDisplayNodeWithBackgroundColor([UIColor blueColor]);
+  secondChild.layoutPosition = CGPointMake(0, 50);
+  secondChild.sizeRange = ASRelativeSizeRangeMakeWithExactCGSize(CGSizeMake(100, 100));
+  
+  [self testWithChildren:@[firstChild, secondChild] sizeRange:sizeRange identifier:identifier];
+}
+
+- (void)testWithChildren:(NSArray *)children sizeRange:(ASSizeRange)sizeRange identifier:(NSString *)identifier
+{
+  ASDisplayNode *backgroundNode = ASDisplayNodeWithBackgroundColor([UIColor whiteColor]);
+
+  NSMutableArray *subnodes = [NSMutableArray arrayWithArray:children];
+  [subnodes insertObject:backgroundNode atIndex:0];
+
+  ASStaticLayoutSpec *staticLayoutSpec = [ASStaticLayoutSpec staticLayoutSpecWithChildren:children];
+  ASLayoutSpec *layoutSpec = [ASBackgroundLayoutSpec backgroundLayoutSpecWithChild:staticLayoutSpec
+                                                                        background:backgroundNode];
+  
+  [self testLayoutSpec:layoutSpec sizeRange:sizeRange subnodes:subnodes identifier:identifier];
+}
+
+@end

AsyncDisplayKitTests/ASTableViewTests.m

@@ -9,18 +9,44 @@
 #import <XCTest/XCTest.h>
 
 #import "ASTableView.h"
+#import "ASTableViewInternal.h"
 #import "ASDisplayNode+Subclasses.h"
+#import "ASChangeSetDataController.h"
 
 #define NumberOfSections 10
 #define NumberOfRowsPerSection 20
 #define NumberOfReloadIterations 50
 
+@interface ASTestDataController : ASChangeSetDataController
+@property (atomic) int numberOfAllNodesRelayouts;
+@end
+
+@implementation ASTestDataController
+
+- (void)relayoutAllNodes
+{
+  _numberOfAllNodesRelayouts++;
+  [super relayoutAllNodes];
+}
+
+@end
+
 @interface ASTestTableView : ASTableView
 @property (atomic, copy) void (^willDeallocBlock)(ASTableView *tableView);
 @end
 
 @implementation ASTestTableView
 
+- (instancetype)initWithFrame:(CGRect)frame style:(UITableViewStyle)style asyncDataFetching:(BOOL)asyncDataFetchingEnabled
+{
+  return [super initWithFrame:frame style:style dataControllerClass:[ASTestDataController class] asyncDataFetching:asyncDataFetchingEnabled];
+}
+
+- (ASTestDataController *)testDataController
+{
+  return (ASTestDataController *)self.dataController;
+}
+
 - (void)dealloc
 {
   if (_willDeallocBlock) {
@@ -219,7 +245,7 @@
   }
 }
 
-- (void)testRelayoutAllRowsWithNonZeroSizeInitially
+- (void)testRelayoutAllNodesWithNonZeroSizeInitially
 {
   // Initial width of the table view is non-zero and all nodes are measured with this size.
   // Any subsequence size change must trigger a relayout.
@@ -233,14 +259,14 @@
 
   tableView.asyncDelegate = dataSource;
   tableView.asyncDataSource = dataSource;
+
+  [tableView layoutIfNeeded];
   
-  // Trigger layout measurement on all nodes
-  [tableView reloadData];
-  
-  [self triggerSizeChangeAndAssertRelayoutAllRowsForTableView:tableView newSize:tableViewFinalSize];
+  XCTAssertEqual(tableView.testDataController.numberOfAllNodesRelayouts, 0);
+  [self triggerSizeChangeAndAssertRelayoutAllNodesForTableView:tableView newSize:tableViewFinalSize];
 }
 
-- (void)testRelayoutAllRowsWithZeroSizeInitially
+- (void)testRelayoutAllNodesWithZeroSizeInitially
 {
   // Initial width of the table view is 0. The first size change is part of the initial config.
   // Any subsequence size change after that must trigger a relayout.
@@ -258,40 +284,10 @@
   [superview addSubview:tableView];
   // Width and height are swapped so that a later size change will simulate a rotation
   tableView.frame = CGRectMake(0, 0, tableViewFinalSize.height, tableViewFinalSize.width);
-  // Trigger layout measurement on all nodes
   [tableView layoutIfNeeded];
   
-  [self triggerSizeChangeAndAssertRelayoutAllRowsForTableView:tableView newSize:tableViewFinalSize];
-}
-
-- (void)triggerSizeChangeAndAssertRelayoutAllRowsForTableView:(ASTableView *)tableView newSize:(CGSize)newSize
-{
-  XCTestExpectation *nodesMeasuredUsingNewConstrainedSizeExpectation = [self expectationWithDescription:@"nodesMeasuredUsingNewConstrainedSize"];
-  
-  [tableView beginUpdates];
-  
-  CGRect frame = tableView.frame;
-  frame.size = newSize;
-  tableView.frame = frame;
-  [tableView layoutIfNeeded];
-  
-  [tableView endUpdatesAnimated:NO completion:^(BOOL completed) {
-    for (int section = 0; section < NumberOfSections; section++) {
-      for (int row = 0; row < NumberOfRowsPerSection; row++) {
-        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:row inSection:section];
-        ASTestTextCellNode *node = (ASTestTextCellNode *)[tableView nodeForRowAtIndexPath:indexPath];
-        XCTAssertEqual(node.numberOfLayoutsOnMainThread, 1);
-        XCTAssertEqual(node.constrainedSizeForCalculatedLayout.max.width, newSize.width);
-      }
-    }
-    [nodesMeasuredUsingNewConstrainedSizeExpectation fulfill];
-  }];
-  
-  [self waitForExpectationsWithTimeout:5 handler:^(NSError *error) {
-    if (error) {
-      XCTFail(@"Expectation failed: %@", error);
-    }
-  }];
+  XCTAssertEqual(tableView.testDataController.numberOfAllNodesRelayouts, 0);
+  [self triggerSizeChangeAndAssertRelayoutAllNodesForTableView:tableView newSize:tableViewFinalSize];
 }
 
 - (void)testRelayoutVisibleRowsWhenEditingModeIsChanged
@@ -304,24 +300,8 @@
   
   tableView.asyncDelegate = dataSource;
   tableView.asyncDataSource = dataSource;
-  
-  XCTestExpectation *reloadDataExpectation = [self expectationWithDescription:@"reloadData"];
-  [tableView reloadDataWithCompletion:^{
-    for (int section = 0; section < NumberOfSections; section++) {
-      for (int row = 0; row < NumberOfRowsPerSection; row++) {
-        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:row inSection:section];
-        ASTestTextCellNode *node = (ASTestTextCellNode *)[tableView nodeForRowAtIndexPath:indexPath];
-        XCTAssertEqual(node.numberOfLayoutsOnMainThread, 0);
-        XCTAssertEqual(node.constrainedSizeForCalculatedLayout.max.width, tableViewSize.width);
-      }
-    }
-    [reloadDataExpectation fulfill];
-  }];
-  [self waitForExpectationsWithTimeout:5 handler:^(NSError *error) {
-    if (error) {
-      XCTFail(@"Expectation failed: %@", error);
-    }
-  }];
+
+  [self triggerFirstLayoutMeasurementForTableView:tableView];
   
   NSArray *visibleNodes = [tableView visibleNodes];
   XCTAssertGreaterThan(visibleNodes.count, 0);
@@ -390,23 +370,7 @@
   tableView.asyncDelegate = dataSource;
   tableView.asyncDataSource = dataSource;
   
-  XCTestExpectation *reloadDataExpectation = [self expectationWithDescription:@"reloadData"];
-  [tableView reloadDataWithCompletion:^{
-    for (int section = 0; section < NumberOfSections; section++) {
-      for (int row = 0; row < NumberOfRowsPerSection; row++) {
-        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:row inSection:section];
-        ASTestTextCellNode *node = (ASTestTextCellNode *)[tableView nodeForRowAtIndexPath:indexPath];
-        XCTAssertEqual(node.numberOfLayoutsOnMainThread, 0);
-        XCTAssertEqual(node.constrainedSizeForCalculatedLayout.max.width, tableViewSize.width);
-      }
-    }
-    [reloadDataExpectation fulfill];
-  }];
-  [self waitForExpectationsWithTimeout:5 handler:^(NSError *error) {
-    if (error) {
-      XCTFail(@"Expectation failed: %@", error);
-    }
-  }];
+  [self triggerFirstLayoutMeasurementForTableView:tableView];
   
   // Cause table view to enter editing mode and then scroll to the bottom.
   // The last node should be re-measured on main thread with the new (smaller) content view width.
@@ -451,4 +415,55 @@
   }];
 }
 
+- (void)triggerFirstLayoutMeasurementForTableView:(ASTableView *)tableView{
+  XCTestExpectation *reloadDataExpectation = [self expectationWithDescription:@"reloadData"];
+  [tableView reloadDataWithCompletion:^{
+    for (int section = 0; section < NumberOfSections; section++) {
+      for (int row = 0; row < NumberOfRowsPerSection; row++) {
+        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:row inSection:section];
+        ASTestTextCellNode *node = (ASTestTextCellNode *)[tableView nodeForRowAtIndexPath:indexPath];
+        XCTAssertEqual(node.numberOfLayoutsOnMainThread, 0);
+        XCTAssertEqual(node.constrainedSizeForCalculatedLayout.max.width, tableView.frame.size.width);
+      }
+    }
+    [reloadDataExpectation fulfill];
+  }];
+  [self waitForExpectationsWithTimeout:5 handler:^(NSError *error) {
+    if (error) {
+      XCTFail(@"Expectation failed: %@", error);
+    }
+  }];
+}
+
+- (void)triggerSizeChangeAndAssertRelayoutAllNodesForTableView:(ASTestTableView *)tableView newSize:(CGSize)newSize
+{
+  XCTestExpectation *nodesMeasuredUsingNewConstrainedSizeExpectation = [self expectationWithDescription:@"nodesMeasuredUsingNewConstrainedSize"];
+  
+  [tableView beginUpdates];
+  
+  CGRect frame = tableView.frame;
+  frame.size = newSize;
+  tableView.frame = frame;
+  [tableView layoutIfNeeded];
+  
+  [tableView endUpdatesAnimated:NO completion:^(BOOL completed) {
+    XCTAssertEqual(tableView.testDataController.numberOfAllNodesRelayouts, 1);
+
+    for (int section = 0; section < NumberOfSections; section++) {
+      for (int row = 0; row < NumberOfRowsPerSection; row++) {
+        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:row inSection:section];
+        ASTestTextCellNode *node = (ASTestTextCellNode *)[tableView nodeForRowAtIndexPath:indexPath];
+        XCTAssertLessThanOrEqual(node.numberOfLayoutsOnMainThread, 1);
+        XCTAssertEqual(node.constrainedSizeForCalculatedLayout.max.width, newSize.width);
+      }
+    }
+    [nodesMeasuredUsingNewConstrainedSizeExpectation fulfill];
+  }];
+  [self waitForExpectationsWithTimeout:5 handler:^(NSError *error) {
+    if (error) {
+      XCTFail(@"Expectation failed: %@", error);
+    }
+  }];
+}
+
 @end