Watch a live presentation at http://offer.bitbar.com/getting-started-with-xctest-and-xcuitest-for-ios-app-testing
XCTest has been part of Xcode for few years already, but it is finally catching up and more developers are getting on the bandwagon. XCTest and XCUITest provide feature-rich capabilities for iOS developers and test automation folks to implement different levels of tests using Xcode features and supported programming languages, Objective-C and Swift.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
The document discusses automation testing for mobile apps using Appium. Appium allows for cross-platform mobile app testing by using the same tests across iOS and Android platforms. It functions by proxying commands to the devices to run tests using technologies like UIAutomation for iOS and UiAutomator for Android. While useful for local testing, Appium has limitations for scaling tests in continuous integration environments, where services like Sauce Labs are better suited.
This presentation covers an introduction to Selenium, the Open Source, cross browser, cross platform functional testing tool. The talk emphasized the importance of applying the same principles to testing (abstraction, refactoring, DRY) that development teams apply to developing software. (This presentation was used for a talk at the Asian Testing Conference)
This document provides an overview of a Selenium training course. The course is divided into modules covering Selenium User, Practitioner, and Expert topics. The Selenium User module focuses on the basics of Selenium and using the Selenium IDE. It includes exercises for locating elements and writing simple test scripts. The document also provides references and demo websites for practicing Selenium.
This document provides an overview of Test Studio, an automated testing tool from Telerik. It allows creating automated tests for web, desktop, and mobile applications without code. For mobile testing, it supports iOS applications. Key features include test recording, data-driven testing, test execution and reporting. The document then focuses on using Test Studio for iOS, covering test creation, recording, and execution steps against both web and native iOS applications.
Katalon Studio - Best automation solution for software testing teamKatalon Studio
Katalon Studio is a test automation solution for mobile, web, and API testing. It offers a simple, powerful, and full-featured solution for both small and large testing teams. Key features include cross-platform support, an intuitive graphical user interface, built-in keywords and templates, and integration with development tools and continuous integration systems.
Introduction to Selenium | Selenium Tutorial for Beginners | Selenium Trainin...Edureka!
( Selenium Training: https://www.edureka.co/testing-with-selenium-webdriver )
This Edureka tutorial on "Introduction to Selenium" will tell you how testing with Selenium WebDriver works. The following topics have been covered in this tutorial:
1. Pain points of Manual Testing
2. Advantages of Automation Testing
3. Introduction to Selenium
4. Selenium vs other tools
5. Demo: Selenium WebDriver in action
Introduction to Selenium blog: https://goo.gl/b523IO
Setting up Page Object Model in Automation Frameworkvaluebound
Using #pageobjectmodel in #automationframework we can make non-brittle test code and reduce or eliminate duplicate test code. In this presentation, Jyoti Prakash of Valuebound has talked about all of the essential concepts and knowledge you need to get started.
----------------------------------------------------------
Get Socialistic
Our website: http://valuebound.com/
LinkedIn: http://bit.ly/2eKgdux
Facebook: https://www.facebook.com/valuebound/
Twitter: http://bit.ly/2gFPTi8
The document discusses NUnit, an open source unit testing framework for .NET. It describes what NUnit is, how to install and use it, key concepts like test fixtures and methods, and provides an example of writing unit tests for a calculator class using NUnit's attributes. The document also covers running tests via the NUnit GUI or console, and examining the output XML file for test results.
Selenium Grid allows running automated tests across different browsers, operating systems, and machines. It works on a master-slave architecture with a hub that distributes tests to node machines. This allows reducing test execution time by running tests in parallel on multiple machines. Selenium Grid supports cross-browser testing and running tests with different data sets on multiple browser instances simultaneously. Setting up a hub is done by running a Java command, and nodes register with the hub using a URL from the hub terminal output. Jenkins can also be configured as a hub to integrate Selenium Grid into a CI/CD pipeline.
The document discusses JUnit 5, the next generation of the JUnit testing framework for Java. Key aspects include a new programming model using extensions, support for Java 8 features, and ways to migrate from earlier JUnit versions. The new framework consists of the JUnit Platform launcher, the JUnit Jupiter API for writing tests, and the JUnit Vintage engine for running JUnit 3 and 4 tests.
Selenium Grid allows maintaining a cluster of Selenium RC servers, configuring tests for different environments, and parallelizing tests. It works by having a Grid Hub that manages Selenium Grid Nodes, which each run a Selenium RC Server. The Hub maps environment names like "linux_firefox_3_6" to specific browsers, and clients connect using environment names. This allows the Hub to route clients to available Nodes matching the requested environment.
This document provides an introduction to unit testing using Nunit. It discusses what unit testing is, the benefits of unit testing, and what is needed to perform unit testing. It then focuses on Nunit, explaining that Nunit is a unit testing framework for .NET languages. It provides hands-on examples of creating a test project using Nunit to test methods in a BMI calculator application. It demonstrates running tests using both the Nunit graphical user interface and console modes.
The document provides an overview of load testing using NeoLoad. It discusses why load testing is important, the differences between functional and load testing, and the main components of NeoLoad including scripting, execution, analysis and monitoring. It then describes the basic process of creating a NeoLoad test including recording a scenario to create a virtual user, setting the population size and scenario, running the test, and analyzing results on things like response times, errors and graphs. Communication between NeoLoad and the server is agentless using push technology.
Introduction to Unified Functional Testing 12 (UFT)Archana Krushnan
This document provides an introduction to Unified Functional Testing (UFT), formerly known as QuickTest Professional (QTP). It discusses what UFT is, some of its key features and advantages over other testing tools. It describes the testing process in UFT including designing test scripts. It provides details on the components of a UFT test script and highlights some limitations of UFT.
The document discusses challenges in mobile automation testing and provides an overview of Appium as a tool for mobile test automation. It covers Appium architecture, requirements, capabilities, and tips for scaling mobile tests. Advanced Appium actions like horizontal and vertical swiping and chained locators are mentioned. The document also discusses visual testing, accessibility testing, and performance testing for mobile apps using Appium.
The document provides an introduction to Selenium WebDriver. It discusses the architecture and components of Selenium 1.0 and 2.0. It describes the Selenium WebDriver API for finding elements, performing actions, and handling windows/frames. It also provides an example of creating a test in Java to validate search results on the Rambler website using Selenium WebDriver.
Unit testing in Android involves testing individual units or components of an Android application to verify their correctness. This is done during development by the developer. The document discusses what unit testing involves, provides examples of unit tests for a number validator class and interval overlapping detector class, and discusses test doubles, constraints of unit testing in Android, where to unit test in an Android app, and test-driven development.
This document discusses test-driven development and unit testing with JUnit. It covers:
- Writing tests before code using stubs, so code is testable and requirements are clear.
- Key aspects of JUnit like test classes, fixtures, assertions and annotations like @Before, @Test.
- Best practices like testing individual methods, writing simple tests first, and repeating the test-code cycle until all tests pass.
- Features of JUnit in Eclipse like generating test stubs from code and viewing test results.
The overall message is that testing saves significant time versus debugging, helps write better code, and is an essential part of the development process. Tests should cover all requirements and edge cases to
Robot Framework is a generic test automation framework for keyword-driven testing. It is implemented with Python and runs on Jython and IronPython as well. It supports test data driven development and has built-in support for reporting, logging, libraries, and integration with tools like Jenkins. The framework is open source and has an active community around it.
Xamarin UI Test allows creating automated UI acceptance tests for Xamarin and native Android and iOS apps. Tests are written in NUnit and can be run locally or in cloud services like Xamarin Test Cloud. Tests interact with apps using a client/server model where a test agent runs on the device. Elements can be identified through IDs, labels, or querying. The Xamarin Test Recorder can also be used to generate test steps. Tests can run on emulators, devices, or Xamarin Test Cloud which analyzes apps on hundreds of real devices.
XCUITest for iOS App Testing and how to test with XcodepCloudy
This document discusses IOS app testing using XCTest and XCUITest. It covers the challenges of IOS automation, current tool options like Appium, XCTest, and XCUITest. It provides an introduction to XCTest and XCUITest, including how to create a basic automation script. It also discusses the impact of XCUITest on Appium, as Appium now proxies commands to XCUITest for IOS 9 and above, rather than the deprecated UIAutomation framework.
This document provides an overview of Calabash, an open source framework for automating acceptance tests for mobile apps. It discusses the main components of Calabash including feature files, step definitions, and support files. It also covers Calabash architecture, how to write feature files with scenarios and steps, configure an iOS app for Calabash testing, and run Calabash tests. The document is intended to help users get started with Calabash testing for an iPhone app.
Brief explanation on mobile applications, specific mobile applications testing considerations. Suggestions on when to do automation for your project, and share some commonly used mobile application automation test frameworks and tools.
Containers are an amazing technology that are revolutionising how we deploy and create applications. Docker and Kubernetes are helping developers and organisations realise the magical potential that container technology and orchestration offer. Enter MicroShed and the Testcontainers framework enabling local test automation that leverages that magical portability containers offer. In this session we'll explore how Testcontainers can help you run and test with true-to-production environments in development with minimal re-writing of your test code.
This document provides an agenda for a training on iOS application penetration testing. It covers topics such as setting up an iOS pen testing environment, understanding the iOS filesystem and Objective-C runtime, runtime analysis and manipulation, insecure data storage, analyzing network traffic, jailbreak detection, secure coding guidelines, and automated testing. Tools discussed include class-dump-z, cycript, clutch, and gdb for analyzing iOS applications.
Mobile Testing Challenges Lighting Talk with www.softtest.ieDavid O'Dowd
Mobile testing presents challenges due to varying screen sizes, operating systems, and devices. Tools like Firefox plugins and Device Anywhere allow testing ad delivery and click-throughs across environments. Varnish helps compare new builds, and Selenium automates functional tests by modifying request headers. PHP and Java test backend detection. Android tools like Robotium and Testdroid automate app tests on real devices. iOS tools include MonkeyTalk, Testing with Frank, and KIF for automation and Cucumber-style tests. Monkeyrunner and Calabash also support cross-platform testing.
JLove - Replicating production on your laptop using the magic of containersGrace Jansen
Containers are an amazing technology that are revolutionising how we deploy and create applications. Docker and Kubernetes are helping developers and organisations realise the magical potential that container technology and orchestration offer. Enter MicroShed and the Testcontainers framework enabling local test automation that leverages that magical portability containers offer. In this session we'll explore how Testcontainers can help you run and test with true-to-production environments in development with minimal re-writing of your test code.
An iOS application penetration testing training covers various topics including:
- Setting up an iOS pen testing environment and understanding the iOS filesystem.
- Understanding the Objective-C runtime and performing runtime analysis and manipulation.
- Analyzing insecure data storage in plist files, NSUserDefaults, CoreData, and the keychain.
- Identifying side channel data leakage through device logs, application snapshots, and the pasteboard.
This document discusses how to take mobile application tests to the next level using continuous integration (CI). It covers challenges with mobile testing in CI, basics of Android and iOS setup, popular automation tools like MonkeyRunner and Sikuli, and demonstrates how to run mobile tests in CI. The session provides tips for configuring emulators and simulators, installing and launching apps, and executing tests on Android and iOS. It also compares instrumentation and non-instrumentation test techniques and popular mobile test automation tools.
Shai Raiten's talk at the SELA Developer Practice (May 2013) about Advanced Coded UI using Visual Studio 2012. This presentation explain how to work with multiple UI maps, how to use various types of data sources, how to use LINQ and Reflection for project refactoring, and how to create and use logs and traces.
This document discusses building mobile apps with Titanium Appcelerator. It provides an overview of Titanium, describing it as a cross-platform JavaScript framework that allows access to native features on iOS and Android. It highlights benefits like native UX, performance, and a simpler development experience compared to writing native code. The document also covers Titanium tools, documentation, modules, and a recommended shift to a CommonJS module structure.
Fashionable XCUITest for iOS Apps by Shashikant JagtapSauce Labs
In this SauceCon 2019 presentation, Shashikant Jagtap discussed how to use a protocol-oriented approach to architect XCUITests that can be scaled easily within iOS CI/CD pipelines. He provides an introduction to XCUITest, covers XCUITest features with Xcode 10, and provides tips for writing CI-friendly XCUITests. e.g Stubs, Accessibility Identifiers, Real Device Tests, Xcode scheme strategy for UI Tests etc.
Continuous integration is a practice where developers integrate code changes frequently from the main code repository. This allows for multiple integrations per day. An automated build is run on each check-in, including running tests to detect errors early. Hudson is a free continuous integration tool written in Java that runs builds, tests, and reports issues. It integrates with source control and build tools via plugins. Eclipse plugins can also be built with Hudson and Buckminster to automate their creation and publication.
This document provides tips for implementing continuous integration (CI) for iOS projects. It recommends starting with the basics of Xcode and the command line, as well as version control and a CI server like Jenkins. Key tips include using scripts instead of plugins for more flexibility, being specific with xcodebuild options, specifying alternate output locations, and ensuring return codes. It also discusses automating tests, code coverage, documentation, and deployment to TestFlight for QA testing. The goal of CI for iOS is to automate building, testing, and deploying code changes to catch issues early and improve quality.
The document discusses XCUITest, Apple's UI testing framework for iOS apps. It provides an overview of XCUITest and tips for using it, including adopting a protocol-oriented test design pattern. It also covers best practices like making accessibility identifiers mandatory, separating test configurations, and writing different types of tests. The document argues for using XCUITest for its benefits like being native, fast, and easy to integrate with CI/CD pipelines. It addresses common excuses for not using XCUITest and emphasizes that it should be used for testing native iOS apps.
This document discusses using AWS Device Farm to perform smoke testing on an Android application. It recommends uploading the APK to Device Farm to test it across over 103 Android devices. It also covers selecting device pools, integrating the smoke tests into a CI/CD pipeline with Jenkins, and posting test results to Slack. While Device Farm allows testing on many real devices, it is noted that it lacks some popular Japanese devices.
This document provides an agenda and objectives for a tutorial on implementing an automated dependency injection framework in a dynamic language like JavaScript. The tutorial will first cover setting up the development environment. It will then demonstrate manual dependency injection in a tic-tac-toe game. Next, it will discuss designing an automated framework to replace manual wiring by injecting types, DOM elements, and events. The framework will be implemented using a test-driven approach. Finally, the simplified wiring code using the framework will be compared to the original manual wiring code.
Similar to Getting Started with XCTest and XCUITest for iOS App Testing (20)
The Best of Both Worlds - Combining Performance and Functional Mobile App Tes...Bitbar
We co-hosted a webinar with Neotys to shed some lights on
- How to overcome the challenges in mobile app performance and functional testing
- How to gain granular and actionable insights to measure and improve your app user experience
- Best practices to get the mobile readiness for 2017 Holiday Shopping Season
- A brief demo of the integration between Neoload and Bitbar Testing
Mobile performance metrics and performance monitoring meetup 2017 05 10Bitbar
Bitbar hosted a local meetup in Helsinki where we discussed mobile performance metrics, performance testing/monitoring and using production data to optimize testing.
Exercising and Scaling Up Mobile DevOps in the EnterpriseBitbar
Adopting the mobile devops culture, processes and practices in any organization may not happen overnight. The transformation from agile to true mobile devops requires identification of inefficiencies and understanding of how process, practice and infrastructure can be scaled up.
Stay tuned and join our upcoming webinars at bitbar.com/testing/webinars/
Hassle-Free Continuous Integration with Real Device TestingBitbar
Watch a live presentation at http://offer.bitbar.com/hassle-free-continuous-integration-combined-with-a-real-device-testing
Thousands of mobile apps are developed and released every day. The fierce competition for attention of end-users has changed the way mobile developers build and test their apps – and how they utilize today’s mobile devops tools to gain advantage of productivity, effectiveness and speed.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Best Practices for DevOps in Mobile App TestingBitbar
Watch a live presentation at http://offer.bitbar.com/best-practices-for-devops-in-mobile-app-testing
In essence, the core of DevOps methodology aims to speed up the app development delivery and process by getting devs and operation specialists to collaborate throughout the end-to-end app development and deployment process.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Ensure Your Mobile Channels Generate Revenue on Holiday Peak DaysBitbar
Watch a live presentation at http://offer.bitbar.com/ensure-your-mobile-channels-generate-revenue-on-holiday-peak-days
Are you – and especially your mobile apps and web channels – ready to make the most of the upcoming holiday season? Being unplugged few minutes or mobile app not being able to deliver means instant loss in revenue. To succeed in this critical time of the year, ‘Sorry, not available’ is not an option for a second during that hectic 6 weeks.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
How to Reliably Measure and Optimize Graphics Performance of Your Android GamesBitbar
Watch a live presentation at http://offer.bitbar.com/measure-and-optimize-graphics-performance-of-android-games
Good graphics performance is closely related to fantastic user experience. That’s why we’ve integrated the unique GameBench profiling tool into Testdroid Cloud. This is a powerful resource for any developer who wants to spot performance bottlenecks and optimize their games across an array of Android devices with different silicon, screen sizes, memory, and many other variances in software and hardware.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Parallel Test Runs with Appium on Real Mobile Devices – Hands-on WebinarBitbar
Watch a live presentation at http://offer.bitbar.com/parallel-test-runs-with-appium-on-real-mobile-devices
Appium is an open source test automation framework and currently one of the hottest framework for mobile app, game and web testing. In this webinar, we’ll discuss about the best practices, how to use Appium for different types of apps, games and web apps, and how to use all new features around it – the parallel test runs, image recognition and more!
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
The Powerful and Comprehensive API for Mobile App Development and TestingBitbar
Watch a live presentation at http://offer.bitbar.com/the-powerful-and-comprehensive-api-for-mobile-app-development-and-testing
Testdroid provides a very powerful and useful API for its users to manage all aspects of mobile development and testing automatically. This powerful API caters your needs to instantly access our device farm, manage your projects, your test runs and results, plus many other things that will make your mobile app, game and web testing smoother, faster and less stressful on real Android and iOS devices.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Which One Works You The Best: In-House or Cloud-Based Development EnvironmentBitbar
Watch a live presentation at http://offer.bitbar.com/which-one-works-you-the-best-in-house-or-cloud-based-development-environment
The best and the most suitable development environment whether it is a full in-house solution with your own devices, servers and other infrastructure – or development infrastructure environment fully hosted for you, depends on various aspects.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Watch a live presentation at http://offer.bitbar.com/learn-the-best-practices-of-mobile-game-testing
To get the best start for your mobile game - or just to improve the existing game's possibility to get in front of hundreds of millions of gamers - we'll be sharing our insights, best practices and lots of tips&tricks how to gain advantage in this race.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Build a Large Scale In-House Test Lab for Mobile AppsBitbar
The document discusses building an in-house test lab for mobile app testing. It outlines the benefits of continuous testing on real devices versus outsourcing. It also covers challenges like device fragmentation and how tools like Testdroid can help automate testing. Infrastructure needs like device control servers, USB hubs and WiFi are reviewed. Tips provided include having an authentic testing environment and integrating testing into the development cycle.
The Status of Android Hardware and Software - From App Developer's Point of ViewBitbar
Watch a live presentation at http://offer.bitbar.com/the-status-of-android-hardware-and-software-from-app-developers-point-of-view
During the Q1’2014, we conducted a major research where we gathered and analyzed data of executed test runs at Testdroid Cloud. There were over 5.4M tests, 100K+ test cases, and 232-269 real Android devices used during three months. This webinar will focus on results, both from hardware and software point of view - and how app developers need to deal with those issues.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Do You Enjoy Espresso in Android App Testing?Bitbar
Watch a live presentation at http://offer.bitbar.com/do-you-enjoy-espresso-in-android-app-testing
Majority of us love coffee but let's put that aside and focus on Espresso - by Google. This exciting new test automation framework just got open sourced and is available for app developers and testers to hammer their app UIs. Espresso has a small, predictable and easy to learn API - built on top of Android Instrumentation Framework - and you can very quickly write concise and reliable Android UI tests with it.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Testing Your Android and iOS Apps with Appium in Testdroid CloudBitbar
Testdroid Cloud is now fully supported with Appium, an open source test automation framework for use with native and hybrid mobile apps.
This slide deck was used on the presentation at Appium Meetup by Jouko Kaasila, Co-founder and COO at Bitbar. You will get an overview of how you can leverage Appium in your mobile app testing within Testdroid Cloud.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
How to Leverage Appium in Your Mobile App TestingBitbar
This document discusses how to leverage Appium for mobile app testing. It begins with an agenda that includes different ways to automate app testing, how Appium compares to other frameworks, using Appium with real devices via Testdroid Cloud, and tips for professional mobile app testing. It then covers various topics on the agenda, such as how Appium works, code examples, its support for Android and iOS, and integrating development and testing. The goal is to help attendees understand how to incorporate Appium into their mobile testing process.
How to Test Security and Vulnerability of Your Android and iOS AppsBitbar
Watch a live presentation at http://offer.bitbar.com/how-to-test-security-and-vulnerability-of-your-android-and-ios-apps
Majority of today’s mobile apps consist of third-party code/libraries. This is a prudent and well-accepted development practice that offloads the task of developing code for non-core functions of your mobile app – or game. Identifying third-party code, its vulnerabilities and its license restrictions, is highly critical in order to understand your security exposure and your liability.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Different Android Test Automation Frameworks - What Works You the Best?Bitbar
Watch a live presentation at http://offer.bitbar.com/different-android-testing-frameworks-what-works-you-the-best
Implementing the test automation as part of your daily activities can provide you an enormous value: coverage to detect bugs and errors, early and later during the development, reducing the costs of failure, save time through its repeatability and earlier verification. Today, there are bunch of different options available for testing frameworks on Android – what would work the best for you?
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Maximize the Benefits from Your Test Automation InvestmentBitbar
Watch a live presentation at http://offer.bitbar.com/maximize-the-benefits-from-your-test-automation-investment
Test automation can actually turn your development to super agile, enable you to start making revenue sooner, improve the overall quality of your applications and process. This new, superior way of development and testing can make you very cost-effective, increase significantly your developer productivity and speed up time-to-market.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...Bert Blevins
Today’s digitally connected world presents a wide range of security challenges for enterprises. Insider security threats are particularly noteworthy because they have the potential to cause significant harm. Unlike external threats, insider risks originate from within the company, making them more subtle and challenging to identify. This blog aims to provide a comprehensive understanding of insider security threats, including their types, examples, effects, and mitigation techniques.
Best Practices for Effectively Running dbt in Airflow.pdfTatiana Al-Chueyr
As a popular open-source library for analytics engineering, dbt is often used in combination with Airflow. Orchestrating and executing dbt models as DAGs ensures an additional layer of control over tasks, observability, and provides a reliable, scalable environment to run dbt models.
This webinar will cover a step-by-step guide to Cosmos, an open source package from Astronomer that helps you easily run your dbt Core projects as Airflow DAGs and Task Groups, all with just a few lines of code. We’ll walk through:
- Standard ways of running dbt (and when to utilize other methods)
- How Cosmos can be used to run and visualize your dbt projects in Airflow
- Common challenges and how to address them, including performance, dependency conflicts, and more
- How running dbt projects in Airflow helps with cost optimization
Webinar given on 9 July 2024
Transcript: Details of description part II: Describing images in practice - T...BookNet Canada
This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator.
Link to presentation recording and slides: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/
Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.
Coordinate Systems in FME 101 - Webinar SlidesSafe Software
If you’ve ever had to analyze a map or GPS data, chances are you’ve encountered and even worked with coordinate systems. As historical data continually updates through GPS, understanding coordinate systems is increasingly crucial. However, not everyone knows why they exist or how to effectively use them for data-driven insights.
During this webinar, you’ll learn exactly what coordinate systems are and how you can use FME to maintain and transform your data’s coordinate systems in an easy-to-digest way, accurately representing the geographical space that it exists within. During this webinar, you will have the chance to:
- Enhance Your Understanding: Gain a clear overview of what coordinate systems are and their value
- Learn Practical Applications: Why we need datams and projections, plus units between coordinate systems
- Maximize with FME: Understand how FME handles coordinate systems, including a brief summary of the 3 main reprojectors
- Custom Coordinate Systems: Learn how to work with FME and coordinate systems beyond what is natively supported
- Look Ahead: Gain insights into where FME is headed with coordinate systems in the future
Don’t miss the opportunity to improve the value you receive from your coordinate system data, ultimately allowing you to streamline your data analysis and maximize your time. See you there!
Are you interested in dipping your toes in the cloud native observability waters, but as an engineer you are not sure where to get started with tracing problems through your microservices and application landscapes on Kubernetes? Then this is the session for you, where we take you on your first steps in an active open-source project that offers a buffet of languages, challenges, and opportunities for getting started with telemetry data.
The project is called openTelemetry, but before diving into the specifics, we’ll start with de-mystifying key concepts and terms such as observability, telemetry, instrumentation, cardinality, percentile to lay a foundation. After understanding the nuts and bolts of observability and distributed traces, we’ll explore the openTelemetry community; its Special Interest Groups (SIGs), repositories, and how to become not only an end-user, but possibly a contributor.We will wrap up with an overview of the components in this project, such as the Collector, the OpenTelemetry protocol (OTLP), its APIs, and its SDKs.
Attendees will leave with an understanding of key observability concepts, become grounded in distributed tracing terminology, be aware of the components of openTelemetry, and know how to take their first steps to an open-source contribution!
Key Takeaways: Open source, vendor neutral instrumentation is an exciting new reality as the industry standardizes on openTelemetry for observability. OpenTelemetry is on a mission to enable effective observability by making high-quality, portable telemetry ubiquitous. The world of observability and monitoring today has a steep learning curve and in order to achieve ubiquity, the project would benefit from growing our contributor community.
Mitigating the Impact of State Management in Cloud Stream Processing SystemsScyllaDB
Stream processing is a crucial component of modern data infrastructure, but constructing an efficient and scalable stream processing system can be challenging. Decoupling compute and storage architecture has emerged as an effective solution to these challenges, but it can introduce high latency issues, especially when dealing with complex continuous queries that necessitate managing extra-large internal states.
In this talk, we focus on addressing the high latency issues associated with S3 storage in stream processing systems that employ a decoupled compute and storage architecture. We delve into the root causes of latency in this context and explore various techniques to minimize the impact of S3 latency on stream processing performance. Our proposed approach is to implement a tiered storage mechanism that leverages a blend of high-performance and low-cost storage tiers to reduce data movement between the compute and storage layers while maintaining efficient processing.
Throughout the talk, we will present experimental results that demonstrate the effectiveness of our approach in mitigating the impact of S3 latency on stream processing. By the end of the talk, attendees will have gained insights into how to optimize their stream processing systems for reduced latency and improved cost-efficiency.
Paradigm Shifts in User Modeling: A Journey from Historical Foundations to Em...Erasmo Purificato
Slide of the tutorial entitled "Paradigm Shifts in User Modeling: A Journey from Historical Foundations to Emerging Trends" held at UMAP'24: 32nd ACM Conference on User Modeling, Adaptation and Personalization (July 1, 2024 | Cagliari, Italy)
How RPA Help in the Transportation and Logistics Industry.pptxSynapseIndia
Revolutionize your transportation processes with our cutting-edge RPA software. Automate repetitive tasks, reduce costs, and enhance efficiency in the logistics sector with our advanced solutions.
Details of description part II: Describing images in practice - Tech Forum 2024BookNet Canada
This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator.
Link to presentation recording and transcript: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/
Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.
Measuring the Impact of Network Latency at TwitterScyllaDB
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
Advanced Techniques for Cyber Security Analysis and Anomaly DetectionBert Blevins
Cybersecurity is a major concern in today's connected digital world. Threats to organizations are constantly evolving and have the potential to compromise sensitive information, disrupt operations, and lead to significant financial losses. Traditional cybersecurity techniques often fall short against modern attackers. Therefore, advanced techniques for cyber security analysis and anomaly detection are essential for protecting digital assets. This blog explores these cutting-edge methods, providing a comprehensive overview of their application and importance.
2. XCTest&XCUITest
• The State of The Art in iOS App Testing
– Frameworks, Tools & Methods
• The Basics of XCTest & XCUITest –
And How to Get Started
• Alternative iOS Test Automation
Frameworks – Pros and Cons of Each
• Demonstration
• Q&A
Agenda
http://bitbar.com/testing/
More informationabout test
automation frameworks for iOS:
bitbar.com/testing/
3. PublicCloud
• Device ‘Cloud’ built for internal testing use
• Enterprise-grade testing infrastructure hosted by the
customer
• Usually sits behind customer firewall and connects to
preproduction environments
• Private Device Cloud
• Reserved and Dedicated devices
• Hosted and Fully Managed by Bitbar
• Devices chosen by and reserved exclusively for
customer
• Also known as Testdroid Cloud
• On-demand devices (multi-tenant)
• Mobile App testing on over 1000+ real Android and
iOS devices hosted by Bitbar
Private Cloud
PRODUCT
UPDATE:
XCTest & XCUITest
Support Available On-Premise
XCTest/XCUITest Supported
4. • Integral framework in Xcode
• Not a new framework: Xcode 5
introduced the first version of XCTest
• Incrementally new
capabilities/features:
o Xcode 6 – performance measurement
o Xcode 7 – UI testing (XCUITest)
• Works with both Swift and Objective-C
XCTest &
XCUITest
What isXCTest/XCUITest?
5. • Easy to learn, no additional installations or
components required (to Xcode)
• Native iOS language support
• Xcode Test Recorder (for XCUITest)
• Integration with Xcode Server (continuous
integration) and Bots
• Faster than many other popular functional
(and cross-platform) test frameworks
• Works with both Swift and Objective-C
XCTest
Pros of XCTest
6. • No cross-platform support
• Limited programming language
support
• Selectors may seem complex
• Requires (always) a separate
test target
• Signing can be ‘tricky’
• Sometimes… well, flaky
XCTest
Cons of XCTest
8. • If you running a test script
built for prior Xcode
versions, all uia_* calls will
raise an error with the latest
Xcode
• When upgrading to Xcode 8
all your existing
UIAutomation scripts will fail
Deprecated
UI Automation
MigratingUIA-> XCTest?
9. The Basics of
XCTest & XCUITest
and
How to Get Started
New Ebook Available!
Download This Guide
10. • A test method is an instance
method of a test class that
begins with prefix “test”
• Tests are simply classes and
methods and e.g. @property
and helper methods can be
added to the class
XCTest &
XCUITest
Getting Started
-(void)testExample {
XCTAssert(...);
XCTAssertTrue(...);
XCTAssertFalse(...);
}
11. • Tests are grouped into
classes that are subclass
from XCTestCase
XCTest &
XCUITest
WritingTest Methods
class DemoTest: XCTestCase {
- (void)testExample {
// This is an example of a functional test case.
// Use XCTAssert and related functions
}
- (void)testPerformanceExample {
// This is an example of a performance test case.
[self measureBlock:^{
// Put the code you want to measure the time of here.
}];
}
}
12. XCTest &
XCUITest
XCTestCase Example - Swift
import UIKit
import XCTest
@testable import LocalizationDemo
class LocalizationDemoTests: XCTestCase {
override func setUp() {
super.setUp()
}
override func tearDown() {
super.tearDown()
}
func testMyModel() {
// Example of a functional test case.
var model = MyModel(name: "first", surname: "last");
XCTAssertEqual(model.a, "first");
XCTAssertNotEqual(model.b, "first");
}
func testIfLocalizationWorks() {
// This is an example of a functional test case.
XCTAssert(true, "Pass")
}
}
13. • A performance test takes a block of code
(that is measured) and runs it ten times,
collecting the average execution time and
the standard deviation for the runs
XCTest &
XCUITest
WritingPerformance Tests
- (void) testAdditionPerformance {
[self measureBlock:^{
// set the initial state
[calcViewController press:[calcView viewWithTag: 6]];
// iterate for 100000 cycles of adding 2
for (int i=0; i<100000; i++) {
[calcViewController press:[calcView
viewWithTag:13]];
[calcViewController press:[calcView viewWithTag:
2]];
[calcViewController press:[calcView
viewWithTag:12]];
}
}];
}
14. XCUIApplication
• The XCUIApplication is basically a
proxy for an app that can be launched
and terminated
• User can tell the application to run in
testing mode by defining app as a
“Target Application” in Xcode target
settings
Code Syntax (XCUITest)
// Objective-C
XCUIApplication *app = [[XCUIApplication alloc] init];
// Swift
let app = XCUIApplication()
15. XCUIElement
• XCUIElement is the
actual UI element in
an iOS application
• XCUIElement
provides all the basics
symbols and
functions for UI
element interactions
• Gestures with XCTest
include clicking UI
elements (normal,
double, pressing),
interacting with the
screen (swipe, pinch,
zoom, rotate etc.)
Code Syntax (XCUITest)
// Click-based functions
tap()
doubleTap()
twoFingerTap()
tap(withNumberOfTaps: UInt, numberOfTouches: UInt)
press(forDuration: TimeInterval)
press(forDuration: TimeInterval, thenDragTo: XCUIElement)
// Generic UI interactions
swipeLeft()
swipeRight()
swipeUp()
swipeDown()
pinch(withScale: CGFloat, velocity: CGFloat)
rotate(CGFloat, withVelocity: CGFloat)
16. XCUIElement
• XCUIElement is
constructed using
the actual user
interface elements
on the screen
• XCUIElement
inherits from
NSObject
• In order to perform
any interaction (tap
on this example) on
a UI element the UI
interactions are
available for use.
Code Syntax (XCUITest)
XCUIApplication *app = [[XCUIApplication alloc] init];
XCUIElement *masterNavigationBar =
app.navigationBars[@"Master"];
XCUIElement *editButton =
masterNavigationBar.buttons[@"Edit"];
// Objective-C
[masterNavigationBar.staticTexts[@"Master"] tap];
[editButton tap];
17. • Two ways to create IPA for
test automation
1. Working with Xcode
2. Working from Command Line
• Test package can be built as
APP file and zipped for
cloud execution
Preparing IPA and
Test Package for
Simultaneous
Device Runs
Methods to Create IPAand Test Package for
Simultaneous Tests
18. • By archiving any build package will
be compatible with an iOS device
• When your build is done and
archiving has finished, select the
build from Archive list and click
“Export…”
Working on
Xcode to Create
IPA for Testing
1. Archive Your Build
19. • When the following window is
shown, simply select “Save for Ad
Hoc Deployment” and click Next.
Working on
Xcode to Create
IPA for Testing
2. Select The Right Method
20. • Use the same identify what you use in
build settings for code signing.
• If your project and Xcode is properly
configured you should see the following
type of dialog proposing the first usable
identifier:
Working on
Xcode to Create
IPA for Testing
3. Identify Yourself(andYourBuild)
21. • It’s almost always recommended to include
all possible device support for your app.
• If you want to reduce the size of your IPA
you can shrink it by selecting to support only
certain devices and OS versions
Working on
Xcode to Create
IPA for Testing
4. Select OS and Devices
22. • This can be done Product -> Build
for -> Testing menu:
Working on
Command Line to
Create IPA for
Testing
1. Select toBuildfor Testing
23. • Next, select your project in Project
Navigator and right click to “Show it in
Finder”:
Working on
Command Line to
Create IPA for
Testing
2. Locate App Fileon HD
24. • After Finder dialog has been opened
and files are shown, just highlight the
.app file and right-click to see copying
option, as follows:
Working on
Command Line to
Create IPA for
Testing
3. Copy App FileProperly
25. • After Finder dialog has been opened
and files are shown, just highlight the
.app file and right-click to see copying
option, as follows:
Working on
Command Line to
Create IPA for
Testing
4. Create IPA from CMD
$ mkdir /tmp/Payload
$ cd /tmp/Payload
$ cp -r /User/Path/Debug-iphoneos/LocalizationDemo.app .
$ cd ..
$ zip --symlinks -qr "LocalizationDemo.ipa" Payload
$ ls -lrt LocalizationDemo.ipa
-rw-r--r-- 1 username staff 0 Dec 16 12:42 LocalizationDemo.ipa
26. • If building for iPhone 5 or iPhone 5C (with
ARMv7 32-bit processor) devices, additional
step is needed before creating the build.
• Starting from Xcode 7, armv7s is no more part
of the default $(ARCHS_STANDARD) and so
should be added as a target build architecture
Creating an IPA
for iOS App
Testing
Good To Know!
28. Top 3 iOS Test Automation Frameworks
XCTEST/XCUITEST APPIUM CALABASH
CROSS-PLATFORM No Yes Yes
IOS Yes Yes Yes
MOBILE WEB Yes Yes No
LANGUAGE Obj-C/Swift Almost any Ruby
TOOL FOR TEST
CREATION
Xcode Appium.app CLI
(Human-Readable syntax)
COMMUNITY Apple Community Community