Read more of this story at Slashdot.
Read more of this story at Slashdot.
C++ unit testing on Linux has always been tricky, especially when mocking static methods or faking legacy behavior. But with Isolator++ v5.4, Typemock makes it faster, more reliable, and fully GCC-compatible.
Whether you’re working with static methods, global functions, or tightly coupled legacy code, the new version simplifies testing for modern C++14 codebases.
The new API now officially support GCC 5.4+ and C++14. This means you can use Typemock’s powerful mocking features on your Linux-based C++ unit tests using the language-based API and is easier to write tests.
For details on C++14 compatibility in GCC 5.4, check the GCC 5.4 release notes.
No more cryptic errors. Isolator++ v5.4 gives clear feedback when mocking fails, saving you hours of confusion.
Global and static functions are now easier to locate and fake—even those with pointer arguments or overloading.
.From("xxx.dll")
You no longer need to manually load libraries. Symbol resolution is now automatic, making test setup smoother and faster.
We’ve fixed a crash in the WillDoInstead
API when mocking functions with 4+ pointer parameters on Windows.
#include "Isolator5.h"
TEST(MyTest, ShouldMockStaticMethod) {
Isolate a;
a.CallTo(SomeService::GetStatus()).WillReturn(200);
int result = MyComponent().Process();
ASSERT_EQ(result, 200);
}
int ExternalApiCall() { return 5; }
TEST(ApiTest, ShouldFakeFreeFunction) {
Isolate a;
a.CallTo(ExternalApiCall).WillReturn(42);
int result = Run(); // internally calls ExternalApiCall
ASSERT_EQ(result, 42);
}
C++ unit testing on Linux often feels like navigating a minefield, especially with tightly coupled code. Isolator++ 5.4 helps you:
And now, your cross-platform builds don’t have to compromise on test quality.
C++ unit testing on Linux doesn’t have to be painful.
Download Isolator++ v5.4 today and bring real mocking power to your GCC projects.
The post C and C++ Unit Testing on Linux Just Got Easier with Isolator++ v5.4 appeared first on Typemock.
In this POST/CON 25 session, Philippe Ozil, Principal Developer Advocate at Salesforce, explores the evolution from chatbots to autonomous agents and demonstrates how to create headless, multi-agent experiences that can revolutionize enterprise workflows.
Key Topics Covered:
- Evolution from chatbots to autonomous AI agents with reasoning and action capabilities
- Headless agents that operate without human chat interfaces for backend automation
- Multi-agent systems with specialized agents collaborating on complex workflows
- Model Context Protocol (MCP) for agent-tool communication
- Agent-to-Agent (A2A) protocol for coordinating tasks between multiple agents
- Salesforce AgentForce integration with Postman flows for enterprise scenarios
What You'll Learn:
- Key differences between LLMs, chatbots, and autonomous agents
- How to design multi-agent systems with orchestrator and specialized agents
- MCP server generation using Postman's public API network
- Building agent workflows with Postman Flows and Actions
- Real-world loan application processing using distributed agent architecture
- Security considerations and challenges in multi-agent environments
00:00 Introduction
02:05 The Evolution to the Agentic Era
03:54 Defining AI Agents: Core Characteristics
05:25 From Agents to Headless Multi-Agent Systems
06:44 Multi-Agent Collaboration
08:03 Multi-Agent System Benefits and Challenges
10:41 Agent-to-Agent (A2A) Protocol
11:06 Model Context Protocol (MCP) Overview
14:24 Postman MCP Integration
16:33 A2A vs MCP
18:51 Live Demo 1: Salesforce CRM Agent Interaction
23:27 Live Demo 2: Agent API Collection
26:42 Postman Flows Integration
30:22 Live Demo 3: Multi-Agent Loan Processing
In this POST/CON 25 session, Santhosh Srinivasan, Senior Cloud Architect at AWS, explores how to leverage your current API ecosystem to build powerful multi-agent systems using the Model Context Protocol (MCP) and standardized communication frameworks.
Key Topics Covered:
- Gartner prediction: 33% increase in AI agents performing human tasks by 2028
- API evolution: From human-focused to AI agent consumption
- Model Context Protocol (MCP) as the "USB-C for agents"
- Multi-agent systems with specialized roles and orchestrated workflows
- LangChain and CrewAI frameworks for building agentic applications
What You'll Learn:
- How to transform existing APIs into AI agent tools using decorators and wrappers
- The anatomy of AI agents: programs, LLMs, tools, and memory systems
- The agentic loop: perceive, reason, act, observe, and re-evaluate
- MCP architecture: servers, clients, and hosts for standardized agent communication
- Building multi-agent workflows with specialized expertise and modularity
00:00 Introduction
02:53 The Paradigm Shift: From Human to AI Consumption
06:05 AI Agents vs. Traditional Chatbots
09:27 The Agentic Loop Explained
12:10 LangChain Tool Implementation
15:55 CrewAI Framework for Multi-Agent Systems
20:50 MCP: Model Context Protocol
25:52 Building MCP Servers
36:34 Demo: Multi-Agent Execution