[iOS] Add iOS test app skeleton #26261

xta0 · 2019-09-16T00:38:05Z

Stack from ghstack:

[iOS] Add iOS test app skeleton #26261 [iOS] Add iOS test app skeleton

Summary

Previously we have enabled the CI jobs for Pull Requests and nightly build

[iOS][Circle CI] Add PR jobs for iOS builds #25840 [iOS][Circle CI] Add PR jobs for iOS builds
[IOS][CIRCLE CI] Nightly build for for iOS #26074 [IOS][CIRCLE CI] Nightly jobs for iOS builds

The testing phase is missing in the nightly build process. Although we are able to generate the build and upload it to the AWS, there is no way to know whether the binary is valid or not (there could be a linking error). To add the test phase to the process, we need

Put a dummy test App in the repo.
After the build jobs finishes, manually links the static libs to the dummy app to produce an executable using the XCode tool chain.
If there is no linking error, then upload the binaries to AWS. If there is an error, then stops the following process and reports an error in CI.

The second and third steps depends on the first step which needs to be landed first.

Test Plan

Don't break any existing CI jobs

Differential Revision: D17408929

ghstack-source-id: 9270059 Pull Request resolved: #26261

shoumikhin · 2019-09-16T05:05:47Z

ios/TestApp/TestApp/AppDelegate.h

@@ -0,0 +1,8 @@
+#import <UIKit/UIKit.h>
+


nit:
Please add NS_ASSUME_NONNULL macros in all headers

shoumikhin · 2019-09-16T05:06:03Z

ios/TestApp/TestApp/AppDelegate.h

+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (strong, nonatomic) UIWindow *window;


nit: strong is default

shoumikhin · 2019-09-16T05:06:40Z

ios/TestApp/TestApp/AppDelegate.m

@@ -0,0 +1,43 @@
+#import "AppDelegate.h"
+
+@interface AppDelegate ()


nit: not needed?

shoumikhin · 2019-09-16T05:06:57Z

ios/TestApp/TestApp/AppDelegate.m

+@implementation AppDelegate
+
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {


nit: may like to remove everything in this file except of this method

shoumikhin · 2019-09-16T05:08:42Z

ios/TestApp/TestApp/Base.lproj/Main.storyboard

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>


nit: ideally we want to build UI in code to be able to review it, so any storyboards other than LaunchScreen should be deprecated

shoumikhin · 2019-09-16T05:09:10Z

ios/TestApp/TestApp/ViewController.mm

+#import "ViewController.h"
+#import <LibTorch/LibTorch.h>
+
+@interface ViewController ()


nit: not needed?

shoumikhin · 2019-09-16T05:10:08Z

ios/TestApp/TestApp/main.m

@@ -0,0 +1,8 @@
+#import <UIKit/UIKit.h>


nit: UIKit import is redundant, since it is already imported by AppDelegate anyway

ezyang · 2019-09-16T14:52:59Z

Hi @xta0, you assigned me as a reviewer on this PR. Is there anything in particular you would like me to review? I am not familiar with iOS so cannot help with those parts ;)

xta0 · 2019-09-16T16:17:48Z

Hi @xta0, you assigned me as a reviewer on this PR. Is there anything in particular you would like me to review? I am not familiar with iOS so cannot help with those parts ;)

Hey @ezyang, please feel free to ignore the iOS code. Just want to sync-up with you that this one is part of the iOS CI process, as the iOS testing approach is different from the approach that our existing nightly jobs are using.

### Summary Previously we have enabled the CI jobs for Pull Requests and nightly build - **#25840 [iOS][Circle CI] Add PR jobs for iOS builds** - **#26074 [IOS][CIRCLE CI] Nightly jobs for iOS builds** The testing phase is missing in the nightly build process. Although we are able to generate the build and upload it to the AWS, there is no way to know whether the binary is valid or not (there could be a linking error). To add the test phase to the process, we need 1. Put a dummy test App in the repo. 2. After the build jobs finishes, manually link the static libs to the dummy app to produce an executable using the xcode tool chain. 3. If there is no linking error, then upload the binaris to AWS. If there is an error, then stops the following process and reports an error in CI. The second and third steps depends on the first step which needs to be landed first. ### Test Plan - Don't break any existing CI jobs

ghstack-source-id: fb99710 Pull Request resolved: #26261

ezyang · 2019-09-17T14:12:35Z

FTR I reviewed the other diff.

facebook-github-bot · 2019-09-17T20:38:29Z

@xta0 merged this pull request in cc61af3.

rohan-varma · 2019-09-18T03:40:32Z

I think this is breaking a CI job that checks that no tabs are used: https://dev.azure.com/pytorch/PyTorch/_build/results?buildId=11551&view=logs

Summary: Pull Request resolved: #27591 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17844036 Pulled By: xta0 fbshipit-source-id: 741f0442a718c9bda706107a2c4c3baed4c37137

## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Differential Revision: [D17844036](https://our.internmc.facebook.com/intern/diff/D17844036)

## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully

…r code signing" ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully

## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully

Summary: Pull Request resolved: #27593 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17848814 Pulled By: xta0 fbshipit-source-id: 48353f001c38e61eed13a43943253cae30d8831a

## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully

Summary: Pull Request resolved: #27594 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) - [#26632](#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17850703 Pulled By: xta0 fbshipit-source-id: ab220061c6e2ec75cae23684ad999c4f9c276820

## Summary Since the nightly jobs are running without any testing code, we don't really have a way to verify the binary before uploading it to AWS. To make the work more solid, I came up with an approach to test our builds. ## How it works The XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. So the approach is link our binaries to a testing app and run `xcodebuild` to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) adds a dummy testing app - [#26632](#26632) adds a ruby script that does all the XCode configuration. The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode (done #27591 ) 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. (done #27593 ) 4. Add the testing code to PR jobs and verify the result. (done #27594 ) 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Differential Revision: [D17893271](https://our.internmc.facebook.com/intern/diff/D17893271)

Summary: Pull Request resolved: #27784 ## Summary Since the nightly jobs are running without any testing code, we don't really have a way to verify the binary before uploading it to AWS. To make the work more solid, I came up with an approach to test our builds. ## How it works The XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. So the approach is link our binaries to a testing app and run `xcodebuild` to see if there is any linking error. The PRs below have already done some of the preparation jobs - [#26261](#26261) adds a dummy testing app - [#26632](#26632) adds a ruby script that does all the XCode configuration. The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode (done #27591 ) 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. (done #27593 ) 4. Add the testing code to PR jobs and verify the result. (done #27594 ) 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17893271 Pulled By: xta0 fbshipit-source-id: cb7679224e062a4884615f625a2933cad8bd4c11

Summary: Pull Request resolved: pytorch#27591 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [pytorch#26261](pytorch#26261) - [pytorch#26632](pytorch#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17844036 Pulled By: xta0 fbshipit-source-id: 741f0442a718c9bda706107a2c4c3baed4c37137

Summary: Pull Request resolved: pytorch#27593 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [pytorch#26261](pytorch#26261) - [pytorch#26632](pytorch#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17848814 Pulled By: xta0 fbshipit-source-id: 48353f001c38e61eed13a43943253cae30d8831a

Summary: Pull Request resolved: pytorch#27594 ## Summary Since the nightly jobs are lack of testing phases, we don't really have a way to test the binary before uploading it to AWS. To make the work more solid, we need to figure out a way to verify the binary. Fortunately, the XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. Now we can link our binary to a testing app and run `xcodebuild` to to see if there is any linking error. The PRs below have already done some of the preparation jobs - [pytorch#26261](pytorch#26261) - [pytorch#26632](pytorch#26632) The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. 4. Add the testing code to PR jobs and verify the result. 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17850703 Pulled By: xta0 fbshipit-source-id: ab220061c6e2ec75cae23684ad999c4f9c276820

Summary: Pull Request resolved: pytorch#27784 ## Summary Since the nightly jobs are running without any testing code, we don't really have a way to verify the binary before uploading it to AWS. To make the work more solid, I came up with an approach to test our builds. ## How it works The XCode tool chain offers a way to build your app without XCode app, which is the [xcodebuild](https://developer.apple.com/library/archive/technotes/tn2339/_index.html) command. So the approach is link our binaries to a testing app and run `xcodebuild` to see if there is any linking error. The PRs below have already done some of the preparation jobs - [pytorch#26261](pytorch#26261) adds a dummy testing app - [pytorch#26632](pytorch#26632) adds a ruby script that does all the XCode configuration. The challenge comes when testing the arm64 build as we don't have a way to code-sign our TestApp. Circle CI has a [tutorial](https://circleci.com/docs/2.0/ios-codesigning/) but is too complicated to implement. Anyway, I figured out an easier way to do it 1. Disable automatically code sign in XCode (done pytorch#27591 ) 2. Export the encoded developer certificate and provisioning profile to org-context in Circle CI (done) 3. Install the developer certificate to the key chain store on CI machines via Fastlane. (done pytorch#27593 ) 4. Add the testing code to PR jobs and verify the result. (done pytorch#27594 ) 5. Add the testing code to nightly jobs and verify the result. ## Test Plan - Both PR jobs and nightly jobs can finish successfully. - `xcodebuild` can finish successfully Test Plan: Imported from OSS Differential Revision: D17893271 Pulled By: xta0 fbshipit-source-id: cb7679224e062a4884615f625a2933cad8bd4c11

[iOS] Add iOS tset app skeleton

80e3832

pytorchbot added the module: infra Relates to CI infrastructure label Sep 16, 2019

Update on "[iOS] Add iOS tset app skeleton"

50cd2bc

xta0 added a commit that referenced this pull request Sep 16, 2019

[iOS] Add iOS tset app skeleton

90eeb83

ghstack-source-id: 9270059 Pull Request resolved: #26261

xta0 requested review from dreiss, ezyang, ljk53 and shoumikhin September 16, 2019 00:44

xta0 added the module: ios Related to iOS support - build, API, Continuous Integration, document label Sep 16, 2019

xta0 changed the title ~~[iOS] Add iOS tset app skeleton~~ [iOS] Add iOS test app skeleton Sep 16, 2019

shoumikhin approved these changes Sep 16, 2019

View reviewed changes

xta0 added a commit that referenced this pull request Sep 16, 2019

[iOS] Add iOS tset app skeleton

6ffdaae

ghstack-source-id: fb99710 Pull Request resolved: #26261

facebook-github-bot closed this in cc61af3 Sep 17, 2019

facebook-github-bot added the merged label Sep 17, 2019

This was referenced Oct 9, 2019

[iOS][CI] Disable automatically code signing for TestApp #27591

Closed

[iOS][CI] Install developer certificate for code signing #27593

Closed

[iOS][CI] add testing code to PR jobs #27594

Closed

xta0 mentioned this pull request Oct 11, 2019

[iOS][CI] add testing code to iOS nightly jobs #27784

Closed

facebook-github-bot deleted the gh/xta0/17/head branch October 28, 2019 22:21

mruberry added the Merged label Oct 28, 2020


		@interface AppDelegate : UIResponder <UIApplicationDelegate>

		@property (strong, nonatomic) UIWindow *window;

		@@ -0,0 +1,43 @@
		#import "AppDelegate.h"

		@interface AppDelegate ()

		@implementation AppDelegate


		- (BOOL)application:(UIApplication )application didFinishLaunchingWithOptions:(NSDictionary )launchOptions {

[iOS] Add iOS test app skeleton #26261

[iOS] Add iOS test app skeleton #26261

Uh oh!

Conversation

xta0 commented Sep 16, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Test Plan

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

shoumikhin Sep 16, 2019

Choose a reason for hiding this comment

Uh oh!

ezyang commented Sep 16, 2019

Uh oh!

xta0 commented Sep 16, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ezyang commented Sep 17, 2019

Uh oh!

facebook-github-bot commented Sep 17, 2019

Uh oh!

rohan-varma commented Sep 18, 2019

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

8 participants

xta0 commented Sep 16, 2019 •

edited

Loading

xta0 commented Sep 16, 2019 •

edited

Loading